def lecture_vtimetable():
current_year = datetime.now().year
recommend = []
if session.get_account():
try:
analogue = LectureAnalogue.objects(
campus_id=session.get_account().campus_id,
student_id=session.get_account().student_id
).get()
lectures1 = Lecture.objects(students__in=[session.get_account().student_id])
lectures2 = Lecture.objects(students__in=[analogue.target])
lectures1 = set([l.subject_code for l in lectures1])
lectures2 = set([l.subject_code for l in lectures2])
lectures = lectures2 - lectures1
for lecture in lectures:
try:
lecture = Lecture.objects(subject_code=lecture)[0]
recommend.append(lecture.subject_name)
except:
pass
except:
pass
return render_template('module/lecture/vtimetable.html', current_year=current_year, recommend=recommend)
def lecture_students(campus_id, year, term, code):
try:
lecture = Lecture.objects(campus_id=campus_id,
year=year, term=Lecture.term_str_to_int(term), code=code).get()
except Lecture.DoesNotExist:
return jsonify({
'error': {
'code': 'lecture_not_exist'
}
}), 404
request_data = request.get_json()
student_id = request_data.get('student_id')
# TODO
"""
from opencampus.module.account.models import Account
try:
account = Account.objects(campus_id=request.campus.id, student_id=student_id).get()
except Account.DoesNotExist:
return jsonify({
'error': {
'code': 'account_not_found'
}
}), 404
"""
#if account.id not in lecture.students:
Lecture.objects(id=lecture.id).update_one(push__students=student_id)
return jsonify({})
def lecture_auth_admin_method_cb(year, term, code):
lecture = Lecture.get_lecture(year, term, code)
from opencampus.module.lecture.authmodels import LectureAuthRequestInfo
request_info = LectureAuthRequestInfo.objects(lecture_id=lecture.id, auth_code=request.args.get('auth_code')).get()
request_info.delete()
Lecture.objects(id=lecture.id).update_one(push__admins=request_info.account_id)
return '인증 완료'
def lecture_admin_administrators(year, term, code):
from opencampus.module.account.models import Account
lecture = Lecture.get_lecture(year, term, code)
if request.method == 'POST':
try:
account = Account.objects(account_id=request.form.get('account_id')).get()
if account.id not in lecture.admins:
Lecture.objects(id=lecture.id).update_one(push__admins=account.id)
except Account.DoesNotExist:
pass
lecture = Lecture.get_lecture(year, term, code)
admins = [Account.objects(id=admin).get() for admin in lecture.admins]
return render_template('module/lecture/detail/admin/administrators.html', year=year, term=term, code=code,
lecture=lecture, admins=admins)
def lecture_sync(campus_id, year, term, code):
try:
lecture = Lecture.objects(campus_id=campus_id,
year=year, term=Lecture.term_str_to_int(term), code=code).get()
except Lecture.DoesNotExist:
return jsonify({
'error': {
'code': 'lecture_not_exist'
}
}), 404
campus = Campus.objects(id=campus_id).get()
campus.get_gateway().sync_lecture(
year=lecture.year,
term=lecture.term_int_to_str(lecture.term),
code=lecture.code
)
return jsonify({})
def lecture_my():
if not session.get_account():
return abort(403)
lectures = []
c_lectures = []
year = -1
term = -1
for lecture in Lecture.objects(Q(students__in=[session.get_account().student_id]) | Q(admins__in=[session.get_account().id])).\
order_by('-year', '-term'):
if lecture.year != year or lecture.term != term:
lectures.append(c_lectures)
c_lectures = []
year = lecture.year
term = lecture.term
c_lectures.append(lecture)
lectures.append(c_lectures)
lectures = lectures[1:]
return render_template('module/lecture/my.html', lectures=lectures)
def load_student_ids(campus_id):
page = 0
student_ids = []
while True:
lectures = Lecture.objects(campus_id=campus_id).skip(20*page).limit(20)
if len(lectures) < 1:
break
print('load page %s' % page)
for lecture in lectures:
for student in lecture.students:
student_ids.append(student)
page += 1
student_ids = list(set(student_ids))
student_ids.sort(reverse=True)
return student_ids
def lecture_update(campus_id, year, term, code):
try:
lecture = Lecture.objects(campus_id=campus_id,
year=year, term=Lecture.term_str_to_int(term), code=code).get()
except Lecture.DoesNotExist:
return jsonify({
'error': {
'code': 'lecture_not_exist'
}
}), 404
request_data = request.get_json()
lecture.type = request_data.get('type', lecture.type)
lecture.subject_code = request_data.get('subject_code', lecture.subject_code)
lecture.subject_name = request_data.get('subject_name', lecture.subject_name)
lecture.credit = int(request_data.get('credit', lecture.credit))
lecture.grade = int(request_data.get('grade', lecture.grade))
lecture.departments = request_data.get('departments', lecture.departments)
lecture.professors = request_data.get('professors', lecture.professors)
lecture.tags = request_data.get('tags', lecture.tags)
lecture.timetable_text = request_data.get('timetable_text', lecture.timetable_text)
if request_data.get('timetable'):
lecture.timetable = []
for time in request_data.get('timetable'):
lecture_time = LectureTime()
if time.get('time'):
lecture_time.start_time = time.get('time').get('start')
lecture_time.end_time = time.get('time').get('end')
if time.get('place'):
lecture_time.place = time.get('place').get('name')
lecture_time.room = time.get('place').get('room')
lecture.timetable.append(lecture_time)
lecture.email = request_data.get('email', lecture.email)
lecture.phone = request_data.get('phone', lecture.phone)
lecture.save()
return jsonify({})
campus_id=campus_id,
student_id=student_id1
)
analogue_obj.point = analogue
analogue_obj.target = student_id2
analogue_obj.save()
print('%s-%s %s' % (student_id1, student_id2, analogue))
campus_page = 0
while True:
campuses = Campus.objects().skip(20*campus_page).limit(20)
if len(campuses) < 1:
break
campus_page += 1
for campus in campuses:
campus_student_ids = load_student_ids(campus.id)
for student_id1 in campus_student_ids:
lecture1 = Lecture.objects(students__in=[student_id1], campus_id=campus.id)
for student_id2 in campus_student_ids:
lecture2 = Lecture.objects(students__in=[student_id2], campus_id=campus.id)
check_data(campus.id, student_id1, lecture1, student_id2, lecture2)
def search(campus_id, query, page, size=24, year=None, term=None):
from opencampus.module.lecture.models import Lecture
results = []
page -= 1
if query == '':
if not year or not term:
query = Lecture.objects(campus_id=campus_id)
else:
query = Lecture.objects(campus_id=campus_id, year=year, term=term)
for lecture in query.skip(page*size).limit(size):
results.append({
'year': lecture.year,
'term_code': lecture.term,
'term': lecture.get_term_text(),
'code': lecture.code,
'type': lecture.type,
'subject_code': lecture.subject_code,
'subject_name': lecture.subject_name,
'credit': lecture.credit,
'grade': lecture.grade,
'departments': lecture.departments,
'professors': lecture.professors,
'tags': lecture.tags if lecture.tags else [],
'term_str': Lecture.term_int_to_str(lecture.term)
})
else:
es = Elasticsearch(hosts=app.config.get('ELASTICSEARCH_HOSTS'))
search_body = {
'from': page*size,
'size': size,
'sort': ['_score', {'year': 'desc'}, {'term_code': 'desc'}],
'query': {
'bool': {
'must': [
{
'query_string': {
'default_field': '_all',
'query': query
}
}
]
}
}
}
if year and term:
search_body['query']['bool']['must'] += [
{
'term': {
'lecture.year': year
}
},
{
'term': {
'lecture.term_code': term
}
}
]
res = es.search(index=_get_index_name(campus_id), body=search_body)
for lecture in res.get('hits').get('hits'):
lecture = lecture.get('_source')
lecture['term_str'] = Lecture.term_int_to_str(lecture['term_code'])
results.append(lecture)
return results
def lecture_admin_administrators_remove(year, term, code):
from opencampus.module.account.models import Account
account = Account.objects(account_id=request.form.get('account_id')).get()
lecture = Lecture.get_lecture(year, term, code)
Lecture.objects(id=lecture.id).update_one(pull__admins=account.id)
return redirect(url_for('campus.lecture_admin_administrators', year=year, term=term, code=code))
