def post(self, request):
"""
add administrator
:author: lishanZheng
:date: 2020/01/06
"""
account = request.data.get('account')
admin = Administrator.objects.filter(account=account)
if admin.count() > 0:
admin_old = Administrator.objects.get(account=account)
if admin_old.state == 0:
admin_old.delete()
else:
return result_util.error(error_code=code.ADMIN_EXIST,
message='此管理员账户已经存在')
privilege_data = request.data.get('privilege')
self.privilege = Privilege.objects.create(**privilege_data)
data = request.data
data['password'] = encrypt(data.get('password'))
administrator = self.get_serializer(data=data)
if administrator.is_valid():
administrator.save()
admin = administrator.data
admin['password'] = ''
return result_util.success(admin)
def put(self, request, primary_key):
"""
update student
:author: lishanZheng
:date: 2020/01/02
"""
student = self.get_object()
if student.id != primary_key:
pass
data = request.data
company_data = data.get("company")
if student.company is None:
company = Company.objects.create(**company_data)
student.company = company
student.save()
else:
company_serializer = CompanySerializer(data=company_data,
partial=True,
instance=student.company)
if company_serializer.is_valid():
company_serializer.save()
student_serializer = StudentSerializer(data=data,
partial=True,
instance=student)
if student_serializer.is_valid():
student_serializer.save()
return result_util.success(student_serializer.data)
def get(self, request):
"""
get student list by letter
:author: lishanZheng
:date: 2020/01/08
"""
queryset = Student.objects.filter(state__in=[NOT_GRADUATE, VALID])
name = self.request.GET.get('name')
city = self.request.GET.get('city')
semester = self.request.GET.get('semester_id')
profession = self.request.GET.get('profession')
if name is not None:
queryset = queryset.filter(name__contains=name)
if semester is not None:
clazz_id = list(
Clazz.objects.filter(semester_id=semester).values_list(
'id', flat=True))
student_set = ClazzStudent.objects.filter(clazz_id__in=clazz_id)
student_id = list(student_set.values_list('student_id', flat=True))
queryset = queryset.filter(id__in=student_id)
if city is not None:
student_set = Student.objects.filter(city__contains=city)
student_id = list(student_set.values_list('id', flat=True))
queryset = queryset.filter(id__in=student_id)
if profession is not None:
queryset = queryset.filter(profession__contains=profession)
queryset = sorted(queryset, key=cmp_to_key(cmp))
student_list = classifier(queryset)
data = {'count': len(queryset), 'results': student_list}
return result_util.success(data)
def put(self, request, primary_key):
"""
update clazz student
:author: gexuewen
:date: 2020/01/10
"""
data = request.data
clazz_student = self.get_object()
state = data.get('state')
if state:
clazz_student.state = state
clazz_student.save()
if state == clazz_student_state.GRADUATED:
student = clazz_student.student
student.state = student_state.VALID
student.save()
evaluation_data = data.get('evaluation')
if evaluation_data:
evaluation = clazz_student.evaluation
evaluation.fraction = evaluation_data.get('fraction')
evaluation.description = evaluation_data.get('description')
evaluation.save()
if not primary_key:
# make pylint happy
print(primary_key)
clazz_student_serializer = ClazzStudentSerializer(clazz_student)
data = clazz_student_serializer.data.copy()
data = remove_key(data, 'clazz')
data = remove_key(data, 'student')
data = remove_key(data, 'apply')
return result_util.success(data)
def login(request):
"""
login
:author: lishanZheng
:date: 2019/12/31
"""
if request.method == 'POST' and request.POST:
account = request.POST.get('account')
password = request.POST.get('password')
correct_password = ''
admin = ''
try:
admin = Administrator.objects.get(account=account)
correct_password = admin.password
except Administrator.DoesNotExist:
return result_util.error(error_code=code.ADMIN_NOT_EXIST,
message='管理员不存在')
if admin.state == 0:
return result_util.error(error_code=code.ADMIN_NOT_EXIST,
message='管理员不存在')
if compare(password, correct_password):
admin.password = ''
request.session['is_login'] = True
admin = AdministratorSerializer(admin).data
request.session['admin'] = admin
return result_util.success(admin)
return result_util.error(error_code=code.INCORRECT_PASSWORD,
message='密码错误')
return result_util.error(error_code=code.EMPTY_REQUEST, message='请求体空')
def put(self, request, primary_key):
"""
update teacher
:author: lishanZheng
:date: 2020/01/04
"""
res = self.update(request, primary_key)
return result_util.success(res.data)
def get(self, request):
"""
get activity list
:author: gexuewen
:date: 2020/01/01
"""
res = self.list(request)
return result_util.success(res.data)
def post(self, request):
"""
create activity
:author: gexuewen
:date: 2020/01/01
"""
res = self.create(request)
return result_util.success(res.data)
def put(self, request, primary_key):
"""
update activity
:author: gexuewen
:date: 2020/01/02
"""
res = self.partial_update(request, primary_key)
return result_util.success(res.data)
def post(self, request):
"""
create semester
:author: lishanZheng
:date: 2020/01/02
"""
res = self.create(request)
return result_util.success(res.data)
def get(self, request):
"""
get semester list
:author: lishanZheng
:date: 2020/01/03
"""
res = self.list(request)
return result_util.success(res.data)
def get(self, request):
"""
get clazz student
:author: gexuewen
:date: 2020/01/09
"""
res = self.list(request).data
return result_util.success(res)
def post(self, request):
"""
add resource
:author: lishanZheng
:date: 2020/01/03
"""
res = self.create(request)
return result_util.success(res.data)
def get(self, request):
"""
get administrator list
:author: lishanZheng
:date: 2020/01/01
"""
page = self.list(request).data
return result_util.success(page)
def get(self, request):
"""
get content list
:author: lishanZheng
:date: 2020/01/09
"""
result_content = self.list(request)
return result_util.success(result_content.data)
def get(self, request):
"""
get course list
:author: lishanZheng
:date: 2020/01/05
"""
result_course_list = self.list(self).data
return result_util.success(result_course_list)
def put(self, request, primary_key):
"""
update course
:author: lishanZheng
:date: 2020/01/05
"""
result_course = self.partial_update(request, primary_key)
return result_util.success(result_course.data)
def get(self, request, primary_key):
"""
get student by id
:author: lishanZheng
:date: 2020/01/11
"""
student = self.get_object()
student.id = primary_key
student = StudentSerializer(student).data
return result_util.success(student)
def get(self, request):
"""
get activity student list
:author: gexuewen
:date: 2020/01/02
"""
data = self.list(request).data
target_results = map(lambda result: result.get('student'),
data.get('results'))
data = {'count': data.get('count'), 'results': list(target_results)}
return result_util.success(data)
def get(self, request):
"""
get activity clazz
:author: gexuewen
:date: 2020/01/03
"""
res = self.list(request)
data = res.data
results = data.get('results')
target_results = list(map(lambda result: result.get('clazz'), results))
data = {'count': data.get('count'), 'results': target_results}
return result_util.success(data)
def post(self, request):
"""
add course
:author: lishanZheng
:date: 2020/01/04
"""
teacher_data = request.data.get('teacher')
self.teacher = Teacher.objects.create(**teacher_data)
course = self.get_serializer(data=request.data)
if course.is_valid():
course.save()
return result_util.success(course.data)
def put(self, request, primary_key):
"""
update administrator
:author: lishanZheng
:date: 2020/01/06
"""
admin = self.get_object()
privilege_id = admin.privilege_id
privilege = Privilege.objects.filter(id=privilege_id)
data = request.data.get('privilege')
privilege.update(**data)
result = self.partial_update(request, primary_key)
return result_util.success(result.data)
def put(self, request, primary_key):
"""
update clazz
:author: gexuewen
:date: 2020/01/04
"""
semester_id = request.data.get('semester_id')
semester = Semester.objects.filter(id=semester_id).first()
if semester is not None:
clazz = self.get_object()
clazz.semester = semester
clazz.save()
res = self.partial_update(request, primary_key)
return result_util.success(res.data)
def get(self, request):
"""
get clazz
:author: gexuewen
:date: 2020/01/04
"""
res = self.list(request)
data = res.data
target_results = map(lambda result: remove_key(result, 'semester'), data.get('results'))
result_data = {
'count': data.get('count'),
'results': list(target_results)
}
return result_util.success(result_data)
def post(self, request):
"""
create clazz
:author: gexuewen
:date: 2020/01/04
"""
data = request.data.copy()
semester_id = data.get('semester_id')
self.semester = Semester.objects.filter(id=semester_id).first()
data.update({'state': UNOPENED})
clazz_serializer = self.get_serializer(data=data)
clazz_serializer.is_valid(raise_exception=True)
clazz_serializer.save()
return result_util.success(clazz_serializer.data)
def get(self, request, activity_id, param):
"""
get activity student record
:author: gexuewen
:date: 2020/01/11
"""
student_id = int(param)
record = ActivityStudent.objects.filter(activity_id=activity_id,
student_id=student_id)
record = record.first()
if record:
activity_student_serializer = ActivityStudentSerializer(record)
return result_util.success(activity_student_serializer.data)
return result_util.error(ACTIVITY_STUDENT_NOT_FOUND, '未参与此活动')
def put(self, request, primary_key):
"""
update semester
:author: lishanZheng
:date: 2020/01/03
"""
key = primary_key
state = request.data.get('state')
if state is not None:
state = int(state)
if state == CLOSED:
clazz_list = Clazz.objects.filter(semester_id=key)
count = len(clazz_list)
clazz_closed = Clazz.objects.filter(semester_id=key, state=clazz_state.CLOSED)
count_closed = len(clazz_closed)
if count != count_closed:
return result_util.error(CLAZZ_NOT_CLOSE, '存在课程没有结束')
res = self.partial_update(request, key)
return result_util.success(res.data)
def post(self, request):
"""
create activity student
:author: gexuewen
:date: 2020/01/03
"""
activity_id = request.data.get('activity_id')
student_id = request.data.get('student_id')
self.activity = Activity.objects.filter(id=activity_id).first()
self.student = Student.objects.filter(id=student_id).first()
activity_student = ActivityStudent.objects.filter(
activity_id=activity_id, student_id=student_id)
if activity_student.count() > 0:
return result_util.error(ALREADY_JOIN, '已经参加过')
data = {'state': WAIT_FOR_PAY}
activity_student_serializer = self.get_serializer(data=data)
activity_student_serializer.is_valid(raise_exception=True)
activity_student_serializer.save()
return result_util.success(activity_student_serializer.data)
def post(self, request):
"""
create activity clazz
:author: gexuewen
:date: 2020/01/03
"""
activity_id = request.data.get('activity_id')
clazz_id = request.data.get('clazz_id')
self.activity = Activity.objects.filter(id=activity_id).first()
self.clazz = Clazz.objects.filter(id=clazz_id).first()
activity_clazz = ActivityClazz.objects.filter(activity_id=activity_id,
clazz_id=clazz_id)
if activity_clazz.count() > 0:
return result_util.error(CLAZZ_ALREADY_IN, '此班级已经在活动列表中')
data = {'activity_id': activity_id, 'clazz_id': clazz_id}
activity_clazz = ActivityClazz.objects.create(**data)
activity_clazz_serializer = self.get_serializer(
instance=activity_clazz)
return result_util.success(activity_clazz_serializer.data)
def login(request):
"""
student login
:author: gexuewen
:date: 2020/01/06
"""
code = request.POST.get('code')
avatar_url = request.POST.get('avatar_url')
gender = request.POST.get('gender')
gender = get_gender(gender)
if gender not in [gender_choice.MALE, gender_choice.FEMALE]:
gender = gender_choice.MALE
if (not avatar_url) or (not avatar_url.startswith('http')):
return result_util.error(INVALID_AVATAR_URL, '头像链接错误')
result = send_login_request(code)
if 'errcode' in result:
return result_util.error(INVALID_JS_CODE, result.get('errmsg'))
open_id = result.get('openid')
session_key = result.get('session_key')
session_id = get_session_id(open_id)
wechat_student = WechatStudent.objects.filter(open_id=open_id).first()
if wechat_student is None:
student = Student.objects.create(avatar_url=avatar_url, gender=gender)
wechat_student = WechatStudent.objects.create(open_id=open_id,
session_key=session_key,
session_id=session_id,
student=student)
else:
wechat_student.session_key = session_key
wechat_student.save()
wechat_student.student.avatar_url = avatar_url
wechat_student.student.gender = gender
wechat_student.student.save()
student_serializer = StudentSerializer(wechat_student.student)
data = {
'session_id': wechat_student.session_id,
'student': student_serializer.data
}
return result_util.success(data)
