def post(self):
if not g.get('admin'):
msg = {
"i_status": 0,
"err_code": 11,
"msg": "not login."
}
return msg
args = user_query_parser.parse_args(strict=True)
s = g.Session()
print(1)
try:
userinfo = db.Users(
name=args['username'],
stu_id=args['student_id'],
password=pbkdf2_sha256.hash(args['password'])
)
s.add(userinfo)
s.commit()
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except:
s.rollback()
msg = {
"i_status": 0,
"err_code": 1,
"msg": "Data of user insert err."
}
finally:
s.close()
return msg
def get(self):
args = parser.events_get_parser.parse_args(strict=True)
session = g.Session()
try:
events = session.query(db.Events).filter(
db.Events.related_class_id == args.get("class_id")).all()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(events, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
session.rollback()
msg = {
"i_status": 0,
"err_code": 15,
"msg": "Events query error.",
"deliver": []
}
finally:
session.close()
return msg
def get(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = users_query_parser.parse_args(strict=True)
ids = [int(id) for id in args.get('u_id').split(',')]
s = g.Session()
result = []
try:
for id in ids:
user = s.query(db.Users).filter(db.Users.id == id).first()
result.append(json.dumps(user, cls=db.AlchemyEncoder))
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": result
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 10,
"msg": "No such user in users.",
"deliver": []
}
finally:
s.close()
return msg
def get(self):
if not g.get('admin'):
msg = {
"i_status": 0,
"err_code": 11,
"msg": "not login."
}
return msg
args = admin_login_parser.parse_args(strict=True)
admin_name = args.get('admin_name')
s = g.Session()
try:
admin = s.query(db.Admins).filter(db.Admins.admin_name == admin_name).first()
if admin is None:
raise Exception("No such admin")
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(admin, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 10,
"msg": "No such admin in admins."
}
return msg
def get(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
s = g.Session()
try:
exams = s.query(db.Exams).all()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(exams, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(str(e))
msg = {
"i_status": 0,
"err_code": 998,
"msg": "Query error.",
}
finally:
s.close()
return msg
def delete(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = exams_charge_delete.parse_args(strict=True)
ids = [int(id) for id in args.get('exam_ids').split(',')]
s = g.Session()
for id in ids:
try:
s.query(db.Exams).filter(db.Exams.id == id).delete()
except Exception as e:
l.error("DELETE {0} failed, ".format(id) + str(e))
try:
s.commit()
except:
l.error("Delete exam failed.")
s.rollback()
finally:
s.close()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
}
return msg
def post(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = event_post_parser.parse_args(strict=True)
session = g.Session()
try:
event = db.Events(
related_class_id = args.get("related_class_id"),
event_type = args.get("event_type"),
event_title = args.get("event_title"),
event_msg = args.get("event_msg"),
)
session.add(event)
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
}
except Exception as e:
l.error(e)
session.rollback()
msg = {
"i_status": 0,
"err_code": 13,
"msg": "Event add err.",
}
finally:
session.close()
return msg
def delete(self):
if not g.get('admin'):
msg = {
"i_status": 0,
"err_code": 11,
"msg": "Not login."
}
return msg
args = class_delete_parser.parse_args(strict=True)
session = g.Session()
try:
Class2Del = session.query(db.Classes).filter(db.Classes.id == args.get('class_id')).one()
session.delete(Class2Del)
session.commit()
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except Exception as e:
l.error(e)
session.rollback()
msg = {
"i_status": 0,
"err_code": 18,
"msg": "Class delete err"
}
finally:
session.close()
return msg
def delete(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = event_delete_parser.parse_args(strict=True)
s = g.Session()
try:
toDel = s.query(db.Events).filter(db.Events.id == args.get('event_id')).one()
s.delete(toDel)
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 14,
"msg": "Delete event err.",
}
finally:
s.close()
return msg
def get(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
s = g.Session()
try:
events = s.query(db.Events).all()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(events, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
s.rollback()
msg = {
"i_status": 0,
"err_code": 13,
"msg": "Event query failed",
"deliver": []
}
finally:
s.close()
return msg
def get(self):
args = judge_get_parser.parse_args(strict=True)
exam_id = args['exam_id']
s = g.Session()
try:
results = s.query(db.ExamResults).filter(db.ExamResults.exam_id == exam_id)
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"delivery": json.dumps(results, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
s.rollback()
msg = {
"i_status": 0,
"err_code": 12,
"msg": "",
}
finally:
s.close()
return msg
def post(self):
args = judge_parser.parse_args(strict=True)
s = g.Session()
try:
judgement = db.Judgement(
id=args['judgement_id'],
q_id=args['q_id'],
judged=args['judged'],
right=args['right'],
score=args['score']
)
s.add(judgement)
s.commit()
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except:
s.rollback()
msg = {
"i_status": 0,
"err_code": 1,
"msg": "Data of judgement insert err."
}
finally:
s.close()
return msg
def get(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = exam_charge_parser_get.parse_args(strict=True)
exam_id = args.get('exam_id')
s = g.Session()
try:
exam = s.query(db.Exams).filter(db.Exams.id == exam_id).first()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
# The AlchemyEncode Serilizer has no feature of decoding datetime
"deliver": json.dumps(exam, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(str(e))
msg = {
"i_status": 0,
"err_code": 998,
"msg": "Query error.",
}
finally:
s.close()
return msg
def delete(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = exam_charge_parser_delete.parse_args(strict=True)
exam_id = args.get('exam_id')
s = g.Session()
try:
exam = s.query(db.Exams).filter(db.Exams.id == exam_id).delete()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
}
except Exception as e:
l.error(str(e))
msg = {
"i_status": 0,
"err_code": 998,
"msg": "Query error.",
}
finally:
s.close()
return msg
def post(self):
if g.get('admin') is None:
msg = {
"i_status": 0,
"err_code": 11,
"msg": "not login."
}
return msg
args = admin_login_parser.parse_args(strict=True)
s = g.Session()
try:
admin_info = db.Admins(
admin_name=args['admin_name'],
password=pbkdf2_sha256.hash(args['password'])
)
s.add(admin_info)
s.commit()
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except:
s.rollback()
msg = {
"i_status": 0,
"err_code": 1,
"msg": "Data of admin insert err."
}
finally:
s.close()
return msg
def get(self):
if not g.get('admin'):
msg = {
"i_status": 0,
"err_code": 11,
"msg": "Not login."
}
return msg
args = user_query_parser.parse_args(strict=True)
user_id = args.get('u_id')
s = g.Session()
try:
user = s.query(db.Users).filter(db.Users.id == user_id).first()
if user is None:
raise Exception("No such user")
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(user, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 10,
"msg": "No such user in users."
}
return msg
def question_set_config_gen(config):
# TODO: need seperate the time parse
start_time_str = config.get('start_time')
duration_str = config.get('duration')
question_set_config = config.get('problem_set_config')
# time caculate
start_time = datetime.datetime.strptime(start_time_str,
'%Y/%m/%d %H:%M:%S')
duration = datetime.datetime.strptime(duration_str, '%H:%M:%S')
duration = datetime.timedelta(hours=duration.hour,
minutes=duration.minute,
seconds=duration.second)
end_time = start_time + duration
# problem set gen
score_config = []
problem_set = {'select': [], 'fill': [], 'fix': [], 'coding': []}
s = g.Session()
try:
for p_conf in question_set_config:
t = p_conf.get('type')
count = p_conf.get('number')
l.debug("CONF:" + str(p_conf))
if count < 0:
l.error('the configure setting is format err.')
raise Exception
score_per = p_conf.get('percentage_tatol')
score_config.append({'type': t, 'percentage': score_per})
q = s.query(db.Questions).filter(db.Questions.question_type == t)
db_count = q.count()
if count > db_count:
l.error('the number of ' + t + 'problem set is not enough' +
'current ' + db_count + 'need ' + count + '.')
raise Exception
problems = q.order_by(func.rand()).limit(count).all()
for problem in problems:
problem_set[t].append(problem.id)
except Exception as e:
l.error(e)
finally:
s.close()
configure = {
'start_time': start_time,
'end_time': end_time,
'question_set': problem_set,
'score_config': score_config
}
return configure
def get(self):
args = judge_commit_parser.parse_args(strict=True)
session = g.Session()
try:
exam = session.query(db.Exams).filter(db.Exams.id == args.get("examresult_id")).one()
scoreConf = func.getScoreInfo(exam.info)
judgements = session.query(db.Judgement).filter(db.Judgement.related_examresults_id == args.get('examresult_id')).all()
judgements = json.dumps(judgements, cls=db.AlchemyEncoder)
eachPart = {}
eachPercent = {}
# get score conf
for t in scoreConf:
eachPercent[t['type']] = t['percentage']
eachPart[t['type']] = 0
eachPart[t['type'] + 'Count'] = 0
# caculate all scores
for judgement in judgements:
q_type = session.query(db.Questions).filter(db.Questions.id == judgement.get('q_id')).one().question_type
eachPart[q_type] += judgement.score
eachPart[q_type + "Count"] += 1
for t in eachPercent.keys():
score += eachPart[t] / eachPart[t + 'Count'] * eachPercent[t]
score = db.Scores(
stu_id = args.get('stu_id'),
score = score
)
session.add(score)
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except Exception as e:
l.error(e)
session.rollback()
msg = {
"i_status": 0,
"err_code": 16,
"msg": "Judge commiment err."
}
finally:
session.close()
return msg
def post(self):
if g.get('user'):
msg = {"i_status": 0, "err_code": 5, "msg": "Already login."}
pass
args = parser.login_parser.parse_args(strict=True)
username = args.get("username")
password = args.get("password")
if not (username and password):
msg = {
"i_status": 0,
"err_code": 2,
"msg": "username or password not provided"
}
return msg
safe = func.check_spell(username) and func.check_spell(password)
if safe:
s = g.Session()
try:
user = s.query(
db.Users).filter(db.Users.name == username).one()
pass_hash = user.password
if pbkdf2_sha256.verify(password, pass_hash):
msg = {"i_status": 1, "err_code": -1, "msg": ""}
session['username'] = username
session['user_id'] = user.id
session['token'] = func.token_gen(user.id)
g.user = {"user_id": user.id}
else:
msg = {
"i_status": 0,
"err_code": 4,
"msg": "password err."
}
except Exception as e:
l.error(e)
msg = {"i_status": 0, "err_code": 3, "msg": "query err."}
finally:
s.close()
return msg
def post(self):
if not g.get('admin'):
msg = {
"i_status": 0,
"err_code": 11,
"msg": "Not login."
}
return msg
args = class_post_parser.parse_args(strict=True)
session = g.Session()
try:
while True:
try:
joinCode = func.genJoinCode()
joinIns = db.JoinCode(
join_code = joinCode
)
session.add(joinIns)
session.commit()
break
except Exception as e:
print(e)
class2add = db.Classes(
class_name = args.get("class_name"),
join_code = joinCode,
describe = args.get("describe")
)
session.add(class2add)
session.commit()
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 17,
"msg": "Class add error"
}
finally:
session.close()
return msg
def get(self):
args = exam_parser.parse_args(strict=True)
exam_id = args.get("exam_id")
s = g.Session()
try:
exam = s.query(db.Exams).filter(db.Exams.id == exam_id).first()
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": exam.get("info")
}
except Exception as e:
l.error(e)
msg = {"i_status": 0, "err_code": 9, "msg": "No such exam."}
return msg
def get_session():
"""
Typically, alchemy sessions are more useful than engines. While there are a few cases where you
want an engine and not a session, if all you're doing is working with your defined models then
the session is what will let you actually do that.
SQLAlchemy uses a `sessionmaker` function which you pass your engine to and it will create a
class (or just function?) that, when instantiated, generates the actual session object itself.
Hence why the result needs to be called.
This, like `get_engine`, can safely fallback to a non-flask-app version outside the flask
application context.
"""
try:
if "Session" not in g:
g.Session = sessionmaker(bind=get_engine())
return g.Session()
except RuntimeError:
return sessionmaker(bind=get_engine())()
def get(self):
args = questions_parser.parse_args(strict=True)
ids = [int(id) for id in args.get('question_ids').split(',')]
s = g.Session()
result = []
try:
for id in ids:
question = s.query(
db.Questions).filter(db.Questions.id == id).first()
result.append(json.dumps(question, cls=db.AlchemyEncoder))
msg = {"i_status": 1, "err_code": -1, "msg": "", "deliver": result}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 10,
"msg": "No such question in exam."
}
return msg
def post(self):
'''
answers format should a list of {'q_id': (int), 'answer': (string)}
so just need send it to ExamResult
then wait to be judge
'''
args = exam_upload_parser.parse_args(strict=True)
s = g.Session()
try:
examResult = db.ExamResults(exam_id=args['exam_id'],
stu_id=args['student_id'],
answers=args['answers'])
s.add(examResult)
s.commit()
msg = {"i_status": 1, "err_code": -1, "msg": ""}
except Exception as e:
print(e)
s.rollback()
msg = {"i_status": 0, "err_code": 1, "msg": "Data insert err."}
finally:
s.close()
return msg
def get(self):
if not g.get('user'):
msg = {"i_status": 0, "err_code": 11, "msg": "not login."}
return msg
args = parser.join_class_parser.parse_args(strict=True)
joinCode = args.get('join_code')
session = g.Session()
try:
classId = session.query(db.Classes.join_code == joinCode).one().id
curUser = session.query(
db.Users.id == int(g.get('user')['user_id'])).one()
curUser.class_id = classId
msg = {"i_status": 1, "err_code": -1, "msg": ""}
except Exception as e:
l.error(e)
msg = {"i_status": 0, "err_code": 19, "msg": "Join class failed."}
session.rollback()
finally:
session.close()
return msg
def post(self):
args = parser.register_parser.parse_args(strict=True)
username = args.get('username')
password = args.get('password')
student_id = args.get('student_id')
if not (username and password and student_id):
msg = {
"i_status": 0,
"err_code": 2,
"msg": "username or password or student_id not provided"
}
return msg
safe = func.check_spell(username) and func.check_spell(password)
if not safe:
msg = {
"i_status": 0,
"err_code": 0,
"msg": "username or password err."
}
else:
s = g.Session()
try:
user = db.Users(name=username,
password=pbkdf2_sha256.hash(password),
stu_id=student_id)
s.add(user)
s.commit()
msg = {"i_status": 1, "err_code": -1, "msg": ""}
except:
s.rollback()
msg = {"i_status": 0, "err_code": 1, "msg": "Data insert err."}
finally:
s.close()
return msg
def get(self):
args = question_parser.parse_args(strict=True)
question_id = args.get('question_id')
s = g.Session()
try:
question = s.query(
db.Questions).filter(db.Questions.id == question_id).first()
if question is None:
raise Exception("No such question")
msg = {
"i_status": 1,
"err_code": -1,
"msg": "",
"deliver": json.dumps(question, cls=db.AlchemyEncoder)
}
except Exception as e:
l.error(e)
msg = {
"i_status": 0,
"err_code": 10,
"msg": "No such question in exam."
}
return msg
def open_repository_session():
if not request.path.startswith('/static'):
from . import db_repo_session
g.Session = scoped_session(db_repo_session)
g.db_repo_session = g.Session()
current_repo.session_begin()
def post(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = exam_charge_parser.parse_args(strict=True)
err = False
try:
l.debug(str(args))
config = {
'start_time': args.get('start_time'),
'duration': args.get('duration'),
'problem_set_config': json.loads(args.get('problem_set_config'))
}
exam_configure = func.question_set_config_gen(config)
except Exception as e:
l.error(str(e))
err = True
if err:
msg = {
"i_status": 0,
"err_code": 8,
"msg": "Configure format err."
}
return msg
s = g.Session()
try:
exam = db.Exams(
name = args.get('title'),
start_t = exam_configure.get('start_time'),
end_t = exam_configure.get('end_time'),
info = str(exam_configure),
describe = args.get('desc')
)
s.add(exam)
s.commit()
except Exception as e:
err = True
l.error(e)
finally:
s.close()
if err:
msg = {
"i_status": 0,
"err_code": 999,
"msg": "General Error, no idea how would it happend."
}
return msg
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
return msg
def post(self):
if g.get('admin'):
msg = {
"i_status": 0,
"err_code": 5,
"msg": "Already login."
}
return msg
args = admin_login_parser.parse_args(strict=True)
adminname = args.get('admin_name') or ""
password = args.get('password') or ""
if not (adminname and password):
msg = {
"i_status": 0,
"err_code": 0,
"msg": "admin username or password not provided when admin"
}
return msg
safe = func.check_spell(adminname) and func.check_spell(password)
if adminname == "root" and pbkdf2_sha256.verify(password, default_passhash):
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
session['adminname'] = "root"
session['admin_id'] = "-1"
session['token'] = func.token_gen(-1)
g.admin = {
"admin_id": -1
}
return msg
if not safe:
msg = {
"i_status": 0,
"err_code": 7,
"msg": "password or username not format well when."
}
return msg
else:
s = g.Session()
try:
admin = s.query(db.Admins).filter(db.Admins.admin_name == adminname).one()
pass_hash = admin.password
if pbkdf2_sha256.verify(password, pass_hash):
msg = {
"i_status": 1,
"err_code": -1,
"msg": ""
}
session['adminname'] = adminname
session['admin_id'] = admin.id
session['token'] = func.token_gen(admin.id)
g.admin = {
"admin_id": admin.id
}
return msg
else:
msg = {
"i_status": 0,
"err_code": 4,
"msg": "password err."
}
return msg
except Exception as e:
# TODO: add a log here
l.error(e)
msg = {
"i_status": 0,
"err_code": 3,
"msg": "query err."
}
return msg
finally:
s.close()
