def showBoardByDynamicScore(request, cId):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
try:
c = Contest.getById(cId)
except:
raise Err(request, 'no resource')
try:
c.canEnterContest(u)
except:
raise Err(request, 'no priv')
return render(request, "newtpl/statistic/board_dynamic_score.html", {
'contest': c,
'tpl': {
'has_priv': Contest.hasPriv(c.course_class, u)
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def showCourseClassProblems(request, course_class_id=None, page_id='1'): # new
logger.info(str(request).replace("\n", "\t"))
"""
views used to show problems that some courseclass can touch
"""
tpl = {'sp': True}
try:
page_id = int(page_id)
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
try:
course_class = CourseClass.getById(course_class_id)
except:
raise Err(
request,
err='no courseclass',
log_format=('{0}'.format(course_class_id), ''),
user_format=(u'{0}'.format(course_class_id), u'干什么呢这是！'),
)
if not course_class.canBeAccessed(u):
raise Err(request, err='no priv')
elif course_class.canBeManaged(u):
# privilge to show all things( univ & shc & c & cc admin)
tpl['can_manage'] = True
else:
tpl['can_show'] = True
if CourseClass.canDoCourseClass(course_class.course, u):
tpl['can_modify'] = True
problems = Problem.objects.filter(course_id=course_class.course.id)
tpl['page_selected'] = 'problem'
paginator = Paginator(problems, Const.PROBLEM_PER_PAGE)
page_id = min(max(int(page_id), 1), paginator.num_pages)
return render(
request,
'newtpl/course/course_class_problem_list.html',
{
'course_class': course_class,
'problem_list': paginator.page(page_id),
'tpl': tpl
},
)
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(
request,
Err.ERROR_PAGE,
{
'errmsg': unicode(e),
},
)
def manageSchool(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not (u.priv == 'university' or u.priv == 'school'):
raise Err(request, 'no priv')
schlist = School.objects.filter(university=u.university)
if u.priv == 'university':
can_manage = True
else:
schlist = schlist.filter(admin=u)
can_manage = False
return render(
request, 'newtpl/user/manageschool.html', {
'school_list': schlist,
'tpl': {
'sp': True,
'can_manage': can_manage,
},
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def update(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if request.method == 'GET':
return render(request, 'newtpl/user/update.html', {'tpl': tpltrue})
nickname = request.POST['nickname']
passwd1 = request.POST['passwd']
passwd2 = request.POST['passwd2']
email = request.POST['email']
gender = request.POST['gender']
if email == '':
email = None
if passwd1 != passwd2:
raise Err(request, 'passwd diff')
try:
if passwd1 != '':
u.update(nickname, passwd1, email, gender)
else:
u.updateNoPass(nickname, email, gender)
except Exception as e:
raise Err(request, str(e))
return redirect('/user/')
except Err as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def addGroup(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
if request.method == 'GET':
school_cddt = School.objects.filter(university=u.university)
admin_cddt = User.objects.filter(priv='group',
university=u.university)
return render(
request, 'newtpl/user/addgroup.html', {
'school_cddt': school_cddt,
'user': u,
'admin_cdt': admin_cddt,
'tpl': tpltrue
})
group_name = request.POST['groupname']
school_id = request.POST['school']
try:
Group.addGroup(group_name, School.objects.get(pk=school_id))
except:
raise Err(request, 'groupname illegal')
return redirect('/user/manage/group/')
except Err:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def listManageProblem(request, pageId="1"): # modified
logger.info(str(request).replace("\n", "\t"))
try:
pageId = int(pageId)
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
if u.priv == 'student':
raise Err(request, 'no priv')
problemList = Problem.problemManageList(u)
"""
tres = Problem.problemList(u)
if (pageId-1)*Const.PROBLEM_PER_PAGE>=len(tres):
raise Err(request, 'unknown err')
res = tres[(pageId-1)*Const.PROBLEM_PER_PAGE:Const.PROBLEM_PER_PAGE]
"""
info = {}
if u.university.isAdmin(u):
info['admin'] = True
return render(request, "newtpl/problem/manageProblemList.html", {
'problem_list': problemList,
'info': info,
'tpl': {
'sp': True
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE, {'errmsg': unicode(e)})
def rejudgeSubmission( request, sid):
logger.info(str(request).replace("\n\r","\t"))
"""
rejudge the very submission with the specific sid
"""
try:
sid = int( sid)
u = User.getSessionUser( request.session)
if not u:
raise Err( request, err='not login')
try:
s = Submission.getById( sid)
except:
raise Err( request, err='no submission',
log_format=( '{0}'.format( sid), ''),
user_format=( u'{0}'.format( sid), u'不要搞笑！！'),
)
if not s.problem_index.contest.course_class.canBeManaged( u):
raise Err( request, err = 'no priv')
Submission.rejudgeSubmission( s)
return redirect( 'Submission:contest_status', contest_id=s.problem_index.contest.cid)
except Exception as e:
logger.error(str(e).replace("\n\r","\t"))
return render( request, Const.NEW_ERROR_PAGE, { 'errmsg': unicode(e), }, )
def addRecord(request, cid):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
c = Contest.getById(cid)
try:
c.canBeManaged(u)
except:
raise Err(request, err='no priv')
cp = c.getContestProblem()
if request.method == 'POST':
form = ChooseProbForm(cp, request.POST)
if form.is_valid():
Cheat.addRecord(cp_set=form.cleaned_data['contest_problem'])
Cheat.antiCheat()
return redirect('Cheat:show_cheat_result', cid=c.cid)
else:
raise Err(request, err='unknown err')
else:
form = ChooseProbForm(cp)
return render(request, 'newtpl/cheat/addRecord.html', {'tpl':{'sp':True,}, 'contest':c, 'form':form,})
except Exception as e:
return render(request, Err.ERROR_PAGE)
def resetGroupMemberPasswd(request, group_id, mode='random'):
logger.info(str(request).replace("\n", "\t"))
try:
try:
g = Group.getById(group_id)
except:
raise Err(request, 'group not exist')
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not (u.priv == 'university'
and u.university == g.school.university):
raise Err(request, 'no priv')
succ = {}
for u in g.allMembers():
newpasswd = u.ResetPasswd(mode)
succ[u.username] = newpasswd
return render(request, 'newtpl/user/resetresult.html', {
'group': g,
'succ': succ,
'tpl': tpltrue
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def addSchool(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
if request.method == 'GET':
form = AddSchoolForm()
return render(request, 'newtpl/user/addschool.html', {
'form': form,
'user': u,
'tpl': tpltrue
})
form = AddSchoolForm(request.POST)
if form.is_valid():
school_abbr = form.cleaned_data['schoolabbr']
school_name = form.cleaned_data['schoolname']
try:
School.addSchool(school_abbr, school_name, u.university)
except Exception as e:
raise Err(request, 'school info illegal')
return redirect('/user/manage/school/')
else:
return render(request, 'newtpl/error.html', {
'errmsg': form._errors,
'user': u
})
except Err as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def listStudent2(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
form = SearchUserForm(request.GET)
if form.is_valid():
username = form.cleaned_data['username']
if username == '':
allstudent = User.objects.filter(university=u.university,
priv='student')
return render(request, 'newtpl/user/allstudent.html', {
'allstudent': allstudent,
'tpl': tpltrue
})
target_user = User.getUserByRawUsername(username)
if not target_user:
raise Err(request, 'no such user')
return redirect('User:viewuser', uid=target_user.uid)
else:
raise Err(request, 'no such user')
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def showContestProblemStatistics(request, p_index=None, cid=None):
logger.info(str(request).replace("\n", "\t"))
"""
view used to show statistics of a problem in a contest
"""
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
cid = int(cid)
c = Contest.getById(cid)
p_index = p_index if p_index else ''
try:
contest_problem = ContestProblem.getBy(c, p_index)
except:
raise Err(
request,
err='no contestproblem',
log_format=('{0}'.format(p_index), ''),
user_format=(u'{0}'.format(p_index), u'搞错了什么吧！'),
)
if not contest_problem.contest.course_class.canBeManaged(u):
raise Err(request, err='no priv')
all_submissions = Submission.submissionList(cp=contest_problem)
submissions = all_submissions.filter(
status='Accepted').order_by('run_time')[:20]
status_list = []
for i in Const.STATUS_CN.iterkeys():
status_list.append({
'name':
Const.STATUS_CN[i],
'number':
all_submissions.filter(status=i).count()
})
for sub_s in submissions:
sub_s.status_color = Const.STATUS_COLOR[
sub_s.status] if sub_s.status in Const.STATUS_COLOR else ''
sub_s.status_cn = Const.STATUS_CN[sub_s.status]
return render(
request, 'newtpl/statistic/contest_problem.html', {
'submissions': submissions,
'contest_problem': contest_problem,
'status_list': status_list,
'tpl': {
'sp': True
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE, {'errmsg': unicode(e)})
def showCourse(request, course_id=None): # new
logger.info(str(request).replace("\n", "\t"))
"""
views used to show Course
"""
tpl = {'sp': True}
try:
course_id = int(course_id)
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
try:
course = Course.getById(course_id)
except:
raise Err(
request,
err='no course',
log_format=('{0}'.format(course_id), ''),
user_format=(u'{0}'.format(course_id), u'别搞笑好嘛！！'),
)
if not course.canBeAccessed(u):
raise Err(request, err='no priv')
else:
tpl['can_manage'] = True
# total privilege( university )
if Course.canDoCourse(course.school.university, u):
tpl['can_modify'] = True
# privilege to set admin( university & school)
if course.canSetAdmin(u):
tpl['can_set_admin'] = True
tpl['page_selected'] = 'index'
# course_classes = CourseClass.getByCourse( course)
# problems = Problem.objects.filter( course_id=course.id)
return render(
request,
'newtpl/course/course.html',
{
'course': course,
'tpl': tpl
},
)
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(
request,
Err.ERROR_PAGE,
{'errmsg': unicode(e)},
)
def showCourseClass(request, course_class_id=None): # new
logger.info(str(request).replace("\n", "\t"))
"""
views used to show CourseClass
"""
tpl = {'sp': True}
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
try:
course_class = CourseClass.getById(course_class_id)
except:
raise Err(
request,
err='no courseclass',
log_format=('{0}'.format(course_class_id), ''),
user_format=(u'{0}'.format(course_class_id), u'干什么呢这是！'),
)
if not course_class.canBeAccessed(u):
raise Err(request, err='no priv')
elif course_class.canBeManaged(u):
# privilge to show all things( univ & shc & c & cc admin)
tpl['can_manage'] = True
else:
tpl['can_show'] = True
# total privilege( university & school)
if CourseClass.canDoCourseClass(course_class.course, u):
tpl['can_modify'] = True
# privilege to set admin( university & school)
if course_class.canSetAdmin(u):
tpl['can_set_admin'] = True
tpl['page_selected'] = 'index'
return render(
request,
'newtpl/course/course_class.html',
{
'course_class': course_class,
'tpl': tpl
},
)
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(
request,
Err.ERROR_PAGE,
{
'errmsg': unicode(e),
},
)
def showContest(request, cId):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
c = Contest.getById(cId)
try:
c.canEnterContest(u)
except:
raise Err(request, 'no priv')
c.course_class_name = unicode(c.course_class.getFullName())
c.description = unicode(c.contest_description)
c.title = unicode(c.contest_title)
now = datetime.now()
c.time_passed = min(
max(int((now - c.start_time).total_seconds()) / 60, 0), c.length)
c.time_passed_percent = 100 * c.time_passed / c.length
c.time_left = c.length - c.time_passed
if c.start_time + timedelta(minutes=c.length) < now:
c.status = 'ended'
elif c.start_time > now:
c.status = 'scheduled'
else:
c.status = 'running'
cn = c.getContestNotice()
priv = Contest.hasPriv(c.course_class, u)
problemList = c.getContestProblem()
for cp, cp_res, cp_user_res in zip(problemList, getContestResult(c=c),
getContestUserResult(c=c, u=u)):
cp.index = cp.problem_index
cp.title = unicode(cp.problem_title)
cp.tlim = cp.problem.prob_time
cp.mlim = cp.problem.prob_memory
cp.ac = cp_res['ac_cnt']
cp.sub = cp_res['sub_cnt']
cp.ratio = cp_res['ac_ratio']
cp.user_res = cp_user_res
return render(
request, 'newtpl/contest/showContest.html', {
'contest': c,
'problem_list': problemList,
'contest_notice_list': cn,
'ccid': c.course_class.id,
'tpl': {
'has_priv': priv,
'nav_act': 'contest',
}
})
except Exception as e:
return render(request, Err.ERROR_PAGE, {
'errmsg': unicode(e),
})
def showResult(request, cid, page='1'):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
c = Contest.getById(int(cid))
try:
c.canBeManaged(u)
except:
raise Err(request, err='no priv')
if ('threshold' in request.GET) and request.GET['threshold']:
threshold = float(request.GET['threshold'])
else:
threshold = Const.CHEAT_DEFAULT_THRESHOLD
cheatList = Cheat.getCheatList(contest=c, threshold=threshold)
paginator = Paginator(cheatList, Const.CHEAT_PER_PAGE)
page = min(max(int(page), 1), paginator.num_pages)
cl = paginator.page(page)
for idx, element in enumerate(cl):
info_a = eval(element.sub1.other_info)
info_b = eval(element.sub2.other_info)
#cl[idx] = {'c': element, 'ip_a': info_a['submit_ip'], 'ip_b': info_b['submit_ip']}
return render(request, 'newtpl/cheat/showResult.html', {
'tpl': {
'sp': True,
},
'contest': c,
'cheat_list': cl
})
except Exception as e:
return render(request, Err.ERROR_PAGE)
# def codeDiff(request, ctid):
# try:
# u = User.getSessionUser(request.session)
# if not u:
# raise Err(request, err='not login')
# ct = Cheat.objects.select_related('sub1__user', 'sub2__user').get(ctid=ctid)
#
# try:
# ct.contest.canBeManaged(u)
# except:
# raise Err(request, err='no priv')
#
# return render(request, 'newtpl/cheat/codeDiff.html', {'tpl':{'sp':True,}, 'sub1':ct.sub1, 'sub2':ct.sub2})
#
#
# except Exception as e:
# return render(request, Err.ERROR_PAGE)
"""
def showContestProblem(request, c_id, idx): # modified
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
c_id = int(c_id)
c = Contest.getById(c_id)
cn = c.getContestNotice()
cp = ContestProblem.getBy(c=c, idx=idx)
try:
c.canEnterContest(u)
except:
raise Err(request, 'no priv')
can_manage = True
try:
c.canBeManaged(u)
except:
can_manage = False
if (not c.canEnterWithTime(u)) and (not can_manage):
raise Err(request, 'contest not started')
c.course_class_name = unicode(c.course_class.getFullName())
p = cp.problem
p.idx = cp.problem_index
p.title = unicode(cp.problem_title)
p.desc = json.loads(p.prob_desc)
cp_list = c.getContestProblem()
for cp, cp_res, cp_user_res in zip(cp_list, getContestResult(c=c),
getContestUserResult(c=c, u=u)):
cp.ac = cp_res['ac_cnt']
cp.sub = cp_res['sub_cnt']
cp.user_res = cp_user_res
return render(
request, "newtpl/problem/showContestProblem.html", {
'c': c,
'cp_list': cp_list,
'contest_notice_list': cn,
'p': p,
'status_query': queryString(problem_index=p.idx),
'tpl': {
'sp': True,
'can_manage': can_manage
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def modifyGroup(request, group_id):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
try:
g = Group.objects.get(pk=group_id)
except:
raise Err(request, 'group not exist')
if g.school.university != u.university:
raise Err(request, 'no priv')
schs = School.objects.filter(university=u.university)
if request.method == 'GET':
init = {'name': g.name, 'school': g.school}
form = ModifyGroupForm(schs, init)
return render(
request, 'newtpl/user/modifygroup.html', {
'form': form,
'group': g,
'users': g.allMembers(),
'schools': schs,
'tpl': tpltrue
})
else:
form = ModifyGroupForm(schs, request.POST)
if form.is_valid():
g.name = form.cleaned_data['name']
g.school = form.cleaned_data['school']
g.save()
return redirect('/user/manage/group/')
else:
return render(
request, 'newtpl/user/modifygroup.html', {
'form': form,
'group': g,
'users': g.allMembers(),
'schools': schs,
'tpl': tpltrue
})
except Err:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def submit(request):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
return render(request, 'newtpl/print/submit.html', {'uname': str(u), 'tpl': {'sp': True}})
except Exception as e:
return render(request, Err.ERROR_PAGE, {'errmsg': unicode(e), }, )
def chooseCourseClass(request):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
if u.isStudent():
raise Err(request, 'no priv')
cc_list = CourseClass.getAllManagedClasses(u)
return render(request, 'newtpl/contest/chooseCourseClass.html', {
'list': cc_list,
'tpl': {
'sp': True
}
})
except Exception as e:
return render(request, Err.ERROR_PAGE)
def addRecord2(request, cid):
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
c = Contest.getById(cid)
try:
c.canBeManaged(u)
except:
raise Err(request, err='no priv')
cp = c.getContestProblem()
Cheat.addRecord(cp_set=cp)
Cheat.antiCheat()
return redirect('Cheat:show_cheat_result', cid=c.cid)
except Exception as e:
return render(request, Err.ERROR_PAGE)
def listStudent(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
allstudent = User.objects.filter(university=u.university,
priv='student')
return render(request, 'newtpl/user/allstudent.html', {
'allstudent': allstudent,
'tpl': tpltrue
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def chooseCourse(request):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
if u.isStudent():
raise Err(request, 'no priv')
cs_list = Course.getAllManagedCourses(u)
return render(request, 'newtpl/problem/chooseCourse.html', {
'list': cs_list,
'tpl': {
'sp': True
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def delMember(request, group_id, user_id):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not u.priv == 'university':
raise Err(request, 'no priv')
g = Group.objects.get(pk=group_id)
utodel = User.objects.get(pk=user_id)
if g.school.university != u.university:
raise Err(request, 'no priv')
if utodel.university != u.university:
raise Err(request, 'no priv')
g.delMember(utodel)
return redirect('/user/modify/group/' + group_id)
except Err:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def deleteProblem(request, problem_id):
logger.info(str(request).replace("\n", "\t"))
try:
user = User.getSessionUser(request.session)
if not user:
raise Err(request, 'not login')
try:
prob = Problem.getById(int(problem_id))
except:
raise Err(request, 'problem illegal')
if not prob.author.university.isAdmin(user):
raise Err(request, 'no priv')
prob.deleteProblem()
messages.add_message(request, messages.SUCCESS,
u'删除题目%d成功' % int(problem_id))
return redirect('Problem:manage')
except Exception as e:
return render(request, Err.ERROR_PAGE, {'errmsg': unicode(e)})
def showProblem(request, p_id): # modified
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
if not u:
raise Err(request, 'not login')
p_id = int(p_id)
p = Problem.getById(p_id)
if not p.canViewProblem(u):
raise Err(request, 'no priv')
p.desc = json.loads(p.prob_desc)
return render(request, "newtpl/problem/showProblem.html", {
'p': p,
'tpl': {
'sp': True
}
})
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def viewUserInfo(request, uid):
logger.info(str(request).replace("\n", "\t"))
try:
u = User.getSessionUser(request.session)
utov = User.objects.get(pk=uid)
if u == False:
raise Err(request, 'not login')
# elif u.priv != 'university':
elif u.priv == 'student' and u.uid != utov.uid:
raise Err(request, 'no priv')
else:
if utov.university != u.university:
raise Err(request, 'no priv')
return render(request, 'newtpl/user/viewuser.html', {
'user': u,
'utov': utov,
'tpl': tpltrue
})
except Err:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE, {'errmsg': Err})
def resetGroupMemberPasswdHomepage(request, group_id):
logger.info(str(request).replace("\n", "\t"))
try:
try:
g = Group.getById(group_id)
except:
raise Err(request, 'group not exist')
u = User.getSessionUser(request.session)
if u == False:
raise Err(request, 'not login')
if not (u.priv == 'university'
and u.university == g.school.university):
raise Err(request, 'no priv')
return render(request, 'newtpl/user/resethomepage.html', {
'group': g,
'tpl': tpltrue
})
except Err as e:
logger.error(str(e).replace("\n", "\t"))
return render(request, Err.ERROR_PAGE)
def courseList(request, page_id='1'): # new
logger.info(str(request).replace("\n", "\t"))
"""
views used to show Course List
"""
tpl = {'sp': True}
try:
page_id = int(page_id)
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
if u.priv == 'university':
tpl['can_modify'] = True
elif u.priv == 'school':
tpl['can_manage'] = True
elif u.priv != 'course':
raise Err(request, err='no priv')
courses = Course.getAllManagedCourses(u)
return render(
request,
'newtpl/course/course_list.html',
{
'course_list': courses,
'tpl': tpl
},
)
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(
request,
Err.ERROR_PAGE,
{
'errmsg': str(e),
},
)
def deleteCourse(request, course_id=None): # new
logger.info(str(request).replace("\n", "\t"))
"""
views used to delete Course
"""
try:
course_id = int(course_id)
u = User.getSessionUser(request.session)
if not u:
raise Err(request, err='not login')
try:
course = Course.getById(course_id)
except:
raise Err(
request,
err='no course',
log_format=('{0}'.format(course_id), ''),
user_format=(u'{0}'.format(course_id), u'别搞笑好嘛！！'),
)
school = course.school
if not Course.canDoCourse(school.university, u):
raise Err(request, err='no priv')
Course.deleteCourse(course_id)
return redirect('User:show_school', school_id=school.id)
except Exception as e:
logger.error(str(e).replace("\n", "\t"))
return render(
request,
Err.ERROR_PAGE,
{
'errmsg': str(e),
},
)