def new_mark():
form = MarkForm()
if form.validate_on_submit():
m = Mark()
form.populate_obj(m)
m.owner_id = g.user.id
m.created = datetime.utcnow()
if form.tags.data:
m.tags = ' '.join([t.strip()
for t in form.tags.data.strip().split(',')])\
.lower()
m.clicks = 0
if not form.title.data:
soup = BSoup(urlopen(form.url.data))
m.title = soup.title.string
db.session.add(m)
db.session.commit()
flash('New mark %s added' % (m.title), category='info')
return redirect(url_for('marks'))
if request.args.get('url'):
form.url.data = request.args.get('url')
if request.args.get('title'):
form.title.data = request.args.get('title')
if request.args.get('type') == 'feed':
form.type.data = 'feed'
return render_template('mark/new.html', title='New mark', form=form)
def create(movie, user_first_name, user_last_name, value):
""" Create a new mark """
mark = Mark(movie=movie,
user_first_name=user_first_name,
user_last_name=user_last_name,
value=value)
return mark.save()
def execute(self, count):
db = self._application.db
datetime = self._application.datetime
c_hash = self._application.hash
random = self._application.random
settings = self._application.settings
with self._application.instance.app_context():
account = Account.query \
.filter(Account.alias == settings[Constant.SETTING_ADMIN_ALIAS]) \
.first()
if account is None:
uuid = c_hash.hex(
c_hash.NORMAL_DIGEST,
datetime.timestamp(),
random.salt(),
Constant.SETTING_ADMIN_ALIAS,
)
account = Account(
alias=settings[Constant.SETTING_ADMIN_ALIAS],
uuid=uuid,
)
db.session.add(account)
token = c_hash.hex(
c_hash.NORMAL_DIGEST,
datetime.timestamp(),
random.salt(),
)
session = Session(
user_device=Device.desktop,
user_digest='',
user_agent='',
user_ip='',
token=token,
)
account.sessions.append(session)
tasks = Task.query \
.filter(Task.active == True) \
.order_by(db.func.random()).limit(count).all()
for task in tasks:
answer = Answer(
result=False,
option_id=None,
)
answer.task = task
answer.session = session
mark = Mark(type=Type.upvote)
mark.task = task
mark.session = session
db.session.commit()
def get_marks(self):
cursor = self.conn.cursor()
cursor.execute(
'select year, quarter, mark, t.*, s.*, l.id, l.name from journal as j, users as t, users as s, lessons as l where student_id = s.id and j.teacher_id = t.id and lesson_id = l.id'
)
rows = cursor.fetchall()
marks = []
for r in rows:
teacher = User(*r[3:12])
student = User(*r[12:21])
lesson = Lesson(*r[21:], teacher)
mark = Mark(*r[:3], teacher, student, lesson)
marks.append(mark)
return marks
def post(self):
try:
data = StudentPostSchema().load(request.get_json())
except ValidationError as err:
return str(err)
if data.get('marks'):
marks = []
for m in data['marks'].split(','):
m_dict = {'mark': int(m.strip())}
try:
m_data = MarkSchema().load(m_dict)
except ValidationError as err:
return str(err)
mark_obj = Mark(**m_data)
marks.append(mark_obj)
data['marks'] = marks
faculty = get_faculty_by_abr_or_name(data['faculty'])
del data['faculty']
if data.get('curator_name') and data.get('curator_surname'):
data['curator'] = Curator.objects.get(
faculty=faculty,
curator_name=data['curator_name'],
curator_surname=data['curator_surname'])
del data['curator_name']
del data['curator_surname']
if not data['curator']:
#raise ValidationError('No curator found with this name on the same faculty as student')
return 'No curator found with this name on the same faculty as student'
data['academic_group'] = AcademicGroup.objects.get(
academic_group_name=data['academic_group'], faculty=faculty)
if not data['academic_group']:
#raise ValidationError('No academic group found with this name on the same faculty as student')
return 'No academic group found with this name on the same faculty as student'
student = Student.objects.create(**data)
return StudentSchema().dump(student)
def get_student_data():
return_ = {}
faculty = random.choice(Faculty.objects())
return_['curator'] = random.choice(Curator.objects(faculty=faculty))
return_['academic_group'] = random.choice(
AcademicGroup.objects(faculty=faculty))
return_['student_card'] = random.randint(0, 100000000000000)
return_['student_name'] = get_random_word(random.randint(2, 10)).title()
return_['student_surname'] = get_random_word(random.randint(2, 15)).title()
return_['marks'] = []
lower_mark = random.randint(2, 5)
for i in range(random.randint(5, 10)):
mark = Mark()
mark.mark = random.randint(lower_mark, 5)
return_['marks'].append(mark)
return return_
def set_mark(request):
from templatetags.marks_chart import get_mark
pupil = get_object_or_404(Pupil,
id=int(request.GET.get('pupil', 0)),
grade=request.user.current_grade)
lesson = get_object_or_404(Lesson,
id=int(request.GET.get('lesson', 0)),
teacher=request.user)
mark = unicode(request.GET.get('mark', 0)).lower()
Mark.objects.filter(pupil=pupil, lesson=lesson).delete()
m = Mark(pupil=pupil, lesson=lesson)
tr_id = 'p-%d-%d' % (pupil.id, lesson.id)
if mark not in ['1', '2', '3', '4', '5', 'n', u'н', '', u'б', u'b']:
return HttpResponse(demjson.encode({'id': tr_id, 'mark': 'no'}))
if mark == '':
return HttpResponse(demjson.encode({'id': tr_id, 'mark': ''}))
if mark in [u'n', u'н', u'b', u'б']:
m.absent = True
if mark in [u'б', u'b']:
m.sick = True
else:
m.mark = int(mark)
m.save()
pupil.get_groups()
if lesson.attendance and lesson.attendance.subject_id in pupil.groups and lesson.attendance.group != pupil.groups[
lesson.attendance.subject_id].value:
mail_admins("lesson cognetive dissonans",
"Lesson id#%d, mark id#%d" % (lesson.id, m.id))
return HttpResponse(
demjson.encode(
{
'id': tr_id,
'mark': get_mark(pupil, [
lesson,
]),
'mark_value': str(m).strip(),
'mark_type': m.get_type()
},
encoding='utf8'))
def post(self):
test_id = self.request.get('test_id')
author_id = self.request.get('author_id')
user = users.get_current_user()
if user:
test = Test.query(Test.id == test_id).get()
mark_query = Mark.query(ancestor=ndb.Key("Entity", user.user_id()))
mark_query = mark_query.filter(Mark.test.id == test.id)
this_mark = mark_query.get()
if this_mark == None:
print "IndexError"
this_mark = Mark(parent=ndb.Key("Entity", user.user_id()))
this_mark.test = test
this_mark.created = datetime.datetime.now()
this_mark.mark = None
this_mark.rated = False
this_mark.rating = 0
test.times_taken += 1
test.put()
this_mark.response = self.request.get('response')
this_mark.complete = False
this_mark.modified = datetime.datetime.now()
this_mark.id = test_id + user.user_id()
this_mark.marker_entity = Entity.query(
Entity.id == author_id).get()
this_mark.taker_entity = Entity.query(
Entity.id == user.user_id()).get()
send_email(this_mark.marker_entity.user.email(), test,
"Test-Answer")
this_mark.put()
self.redirect('/t/%s' % test_id)
return
def put(self, id):
student = Student.objects.get(id=id)
try:
data = StudentPutSchema().load(request.get_json())
except ValidationError as err:
return str(err)
if data.get('marks'):
marks = []
for m in data['marks'].split(','):
m_dict = {'mark': int(m.strip())}
try:
m_data = MarkSchema().load(m_dict)
except ValidationError as err:
return str(err)
mark_obj = Mark(**m_data)
marks.append(mark_obj)
data['marks'] = marks
if data.get('faculty'):
faculty = get_faculty_by_abr_or_name(data['faculty'])
del data['faculty']
if data.get('curator_name') and data.get('curator_surname'):
data['curator'] = Curator.objects.get(
faculty=faculty,
curator_name=data['curator_name'],
curator_surname=data['curator_surname'])
if not data['curator']:
#raise ValidationError('No curator found with this name on the same faculty as student')
return 'No curator found with this name on this faculty'
del data['curator_name']
del data['curator_surname']
if data.get('academic_group'):
data['academic_group'] = AcademicGroup.objects.get(
academic_group_name=data['academic_group'], faculty=faculty)
if not data['academic_group']:
#raise ValidationError('No academic group found with this name on the same faculty as student')
return 'No academic group found with this name on this faculty'
if (data.get('curator') and
not data.get('academic_group') and
data.get('curator').faculty != student.faculty) or \
(not data.get('curator') and
data.get('academic_group') and
student.curator and
data.get('academic_group').faculty != student.curator.faculty):
# raise ValidationError('Group and curator are in different faculties')
return 'Group and curator are in different faculties'
student.modify(**data)
return StudentSchema().dump(student)
def create():
class_name = request.json.get('class_name')
term_begin = request.json.get('term_begin')
term_end = request.json.get('term_end')
class_master = request.json.get('master_number')
grades = [
'大一上学期', '大一下学期', '大二上学期', '大二下学期', '大三上学期', '大三下学期', '大四上学期', '大四下学期'
]
subject_name = []
# build class
new_class = FzuClass.query.filter(FzuClass.name == class_name).first()
if not new_class:
new_class = FzuClass(name=class_name)
db.session.add(new_class)
if not db_commit():
return jsonify({'status': 303}), 303
# build student
data = pd.read_excel('mark.xls', usecols=[0, 1], converters={
0: str
}).values
for (student_number, name) in data:
_user = User.query.filter(
User.student_number == student_number).first()
if _user:
continue
else:
user = User(student_number=student_number,
password=student_number,
name=name)
user.class_id = new_class.id
db.session.add(user)
if not db_commit():
return jsonify({'status': 303}), 303
# build mark
for i in range(term_end - term_begin + 1):
data = pd.read_excel('mark.xls', sheet_name=[i], converters={0:
str})[i]
(r, c) = data.shape
columns = data.columns.values.tolist()
subject_name.extend(columns[2:])
for j in range(r):
user = User.query.filter(
User.student_number == data.iloc[j, 0]).first()
average = float(data.iloc[j, 2:].mean())
for k in range(2, c):
mark = Mark(name=columns[k],
mark=float(data.iloc[j, k]),
user_id=user.id,
class_id=new_class.id)
mark.grade = grades[term_begin + i]
mark.segment = get_segment(mark.mark)
mark.average = average
db.session.add(mark)
for k in range(2, c):
df = data.iloc[:, k]
class_mark = Class_mark(
name=columns[k],
max_s=float(df.max()),
min_s=float(df.min()),
average=float(df.mean()),
grade=grades[term_begin + i],
pass_rate=float(df[df >= 60].count() / len(df) * 100),
good_rate=float(df[df >= 90].count() / len(df) * 100),
class_id=new_class.id)
db.session.add(class_mark)
if not db_commit():
return jsonify({'status': 303}), 303
# build rank
create_rank(class_id=new_class.id)
# build class master
set_master(student_number=class_master)
return jsonify({'status': 200}), 200
async def index(**kw):
#用户登录：接受客户端传来的code和nickname，从微信服务器获取openin和session_key，检索数据库，有则更新，无则增加一条记录
if kw.get('code', None) and kw.get('nickName', None):
print(appId)
wxAPIURL = 'https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code' % (
appId, appSecret, kw.get('code'))
async with ClientSession() as session:
async with session.get(wxAPIURL) as resp:
#resp.text()是json格式的文本，需处理
openidAndsession_key = json.loads(await resp.text())
currentUser = await User.find(openidAndsession_key.get('openid'))
if currentUser:
#以防用户改过微信昵称，每次登录及时储存当前微信昵称
currentUser.nickName = kw.get('nickName')
await currentUser.update()
#返回openid字符串作为SessionId
return currentUser.id
else:
#openid字符串同时作为主键便于查找
currentUser = User(
id=openidAndsession_key.get('openid'),
session_key=openidAndsession_key.get('session_key'),
nickName=kw.get('nickName'))
await currentUser.save()
return currentUser.id
#获取用户答案，更新Answer表
if kw.get('answer', None) and kw.get('question_id', None) and kw.get(
'SessionId', None):
score = calculate_question_functionDict[kw.get('question_id')](
kw.get('answer'))
answer = Answer(answerText=kw.get('answer'),
question_id=kw.get('question_id'),
user_id=kw.get('SessionId'),
markNumByMachine=score)
await answer.save()
return answer.markNumByMachine
#获取题库以及答案列表
if kw.get('listName', None):
examinations = await Examination.findAll()
for e in examinations:
e['open'] = False
e['titles'] = [t for t in await Title.findAll('exam_id=?', e.id)]
for t in e['titles']:
t['questions'] = [
qs for qs in await Question.findAll('title_id=?', t.id)
]
return json.dumps(examinations)
#添加反馈到FeedBack表
if kw.get('feedback', None) and kw.get('SessionId', None):
currentUser = await User.find(kw.get('SessionId'))
feedback = Feedback(feedbackContent=kw.get('feedback'),
userId=currentUser.id,
nickName=currentUser.nickName)
await feedback.save()
return 'done'
#根据titleId查询user，并返回respondents
if kw.get('titleId', None):
respondents = {}
for question in await Question.findAll('title_id=?',
kw.get('titleId')):
for answer in await Answer.findAll('question_id=?',
question.id,
orderBy='create_at asc'):
u = await User.find(answer.user_id)
pickerArray = ['请选择分数，确定即提交', 0]
for i in range(question.fullMark):
pickerArray.append(i + 1)
if answer.user_id + u.nickName in respondents:
#用user_id加上nickName作为key是避免出现用户有相同昵称，所以在value中还加上了user_id，方便客户端将key中的user_id去掉
respondents[answer.user_id + u.nickName].append({
'user_id':
answer.user_id,
'answer_id':
answer.id,
'answerText':
answer.answerText,
'markNumByMachine':
answer.markNumByMachine,
'question_id':
answer.question_id,
'pickerArray':
pickerArray,
'pickerIndex':
0,
'display':
'none'
})
else:
respondents[answer.user_id + u.nickName] = [{
'user_id':
answer.user_id,
'answer_id':
answer.id,
'answerText':
answer.answerText,
'markNumByMachine':
answer.markNumByMachine,
'question_id':
answer.question_id,
'pickerArray':
pickerArray,
'pickerIndex':
0,
'display':
'none'
}]
return json.dumps(respondents)
#根据titleId查询对应用户的答案
if kw.get('answeredTitleId', None):
questionsAnswered = []
for question in await Question.findAll('title_id=?',
kw.get('answeredTitleId')):
questionsAnswered.append({
'questionContent': question.questionContent,
'markReference': question.markReference,
'id': question.id,
'answers': []
})
return json.dumps(questionsAnswered)
#获取用户评分，存到Mark表中
if kw.get('markNumByUser', None) and kw.get(
'user_mark_id', None) and kw.get('answer_id', None):
mark = Mark(user_mark_id=kw.get('user_mark_id'),
answer_id=kw.get('answer_id'),
markNumByUser=kw.get('markNumByUser'))
await mark.save()
return '稳了'
#根据I_mark_sessionId和questions数组得到I_mark_table表格
if kw.get('I_mark_sessionId', None) and kw.get('questionIds', None):
I_mark_table = {}
for marksByMe in await Mark.findAll(
'user_mark_id=?',
kw.get('I_mark_sessionId'),
orderBy='create_at asc'): #查询该用户打得分，按时间升序排列
for questionId in json.loads(kw.get('questionIds')):
I_mark_table.setdefault(questionId, [])
for answer in await Answer.findAll(
'question_id=?', questionId,
orderBy='create_at asc'): #查询某道题的回答，按时间升序排列
#当该用户打分的answer_id与根据question_id查询到的answer_id相等时，则是该用户给这道题打的所有分，有可能同道题同个人答了多次，也可能给同个人的一次答题打了多次分
if answer.id == marksByMe.answer_id:
userAnswered = await User.find(answer.user_id)
I_mark_table[questionId].append({
'answerText':
answer.answerText,
'userNickname':
userAnswered.nickName,
'markNumByMachine':
answer.markNumByMachine,
'markNumByUser':
marksByMe.markNumByUser
})
return json.dumps(I_mark_table)
#根据sessionId和questions数组得到I_mark_table表格
if kw.get('mark_me_sessionId', None) and kw.get('questionIds', None):
mark_me_table = {}
for questionId in json.loads(kw.get('questionIds')):
mark_me_table.setdefault(questionId, [])
for answer in await Answer.findAll('question_id=?',
questionId,
orderBy='create_at asc'):
if answer.user_id == kw.get('mark_me_sessionId'):
tableList = []
for mark in await Mark.findAll('answer_id=?', answer.id):
user = await User.find(mark.user_mark_id)
tableList.append({
'userNickname': user.nickName,
'markNumByUser': mark.markNumByUser
})
mark_me_table[questionId].append({
'answerText':
answer.answerText,
'markNumByMachine':
answer.markNumByMachine,
'table':
tableList
})
return json.dumps(mark_me_table)
def create(movie_id, user_id, note):
""" Create a new mark """
mark = Mark(movie_id=movie_id, user_id=user_id, note=note)
return mark.save()
