def get_object(self):
token = self.request.GET.get('token', None)
try:
token.confirm_validate_token(token, expiration=600)
return super().get_object()
except:
return
def dispatch(self, request, *args, **kwargs):
if settings.DEBUG == True:
return super().dispatch(request, *args, **kwargs)
tk = request.META.get('HTTP_TOKEN', '')
try:
token.confirm_validate_token(tk)
return super().dispatch(request, *args, **kwargs)
except:
try:
hs = encrypt.getHash(tk)
models.User.objects.get(wechat=hs)
return super().dispatch(request, *args, **kwargs)
except:
return HttpResponseForbidden('{"error":"forbidden"}',
content_type="application/json")
def connect(self):
self.group_name = 'default'
try:
query_dict = get_query_dict(self.scope['query_string'])
except Exception as e:
# Bad Request
self.close()
return
# 将两个用户的id排序后用下划线连接，作为组名
self.sender_token = query_dict['sender']
try:
self.sender_id = str(
token.confirm_validate_token(self.sender_token))
except:
# 未登录
self.close()
return
self.receiver_id = query_dict['receiver']
if self.sender_id == self.receiver_id:
# 不能自己给自己发
self.close()
return
self.joined_user = [self.sender_id, self.receiver_id]
self.joined_user.sort()
self.group_name = '_'.join(self.joined_user)
self.joined_user = [int(i) for i in self.joined_user]
async_to_sync(self.channel_layer.group_add)(self.group_name,
self.channel_name)
self.accept()
def resolve_get_messages_by_receiver(self, info, **kwargs):
try:
realuser = token.confirm_validate_token(info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return
receiver = kwargs['receiver']
# 不能获取与自己无关的消息
if realuser.pk != receiver:
return
return models.Message.objects.filter(receiver=receiver)
def upload_file(request):
file = request.FILES.get('data', None)
tk = request.META['HTTP_TOKEN']
try:
realuser = token.confirm_validate_token(tk)
except:
try:
realuser = models.User.objects.get(wechat=getHash(tk)).pk
except:
return Response(data={"msg": "forbidden"})
upload_user_id = realuser
newfile = models.HWFFile.objects.create(
data=file, initial_upload_user_id=upload_user_id)
return Response(data={"id": newfile.pk})
def confirm_forgotten(request):
init()
global data, headers, token
userid = token.confirm_validate_token(request.META['HTTP_TOKEN'],
expiration=600)
if userid:
user_obj = User.objects.get(pk=userid)
user_obj.forgotten = True
user_obj.save()
data['result'] = results['SUCCESS']
serializer = serializers.UserSerializer(user_obj)
data['data'] = serializer.data
return Response(data=data, headers=headers)
data['result'] = results['EXPIRED']
return Response(data=data, headers=headers)
def has_permission(self, request, view):
if request.method in permissions.SAFE_METHODS:
return True
try:
vtoken = request.META['HTTP_TOKEN']
if token.confirm_validate_token(vtoken):
return True
except:
openid = request.data['openid']
hs = encrypt.getHash(openid)
try:
User.objects.get(wechat=hs)
return True
except:
return False
return False
def resolve_get_messages_by_sender_and_receiver(self, info, **kwargs):
try:
realuser = token.confirm_validate_token(info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return
sender = kwargs['sender']
receiver = kwargs['receiver']
# 不能获取与自己无关的消息
if realuser.pk != sender and realuser.pk != receiver:
return
# 获取两个用户之间相互的信息
result = Q(sender=sender) & Q(receiver=receiver) | Q(sender=receiver) & Q(receiver=sender)
return models.Message.objects.filter(result).order_by("send_time")
def get_qrcode(request):
try:
realuser = token.confirm_validate_token(request.META['HTTP_TOKEN'])
new_token = token.generate_validate_token(realuser)
except:
return Response(data={"error": "forbidden"})
qr = qrcode.make("http://" + BACKEND_DOMIAN + "/data/courses/" +
str(request.data['course_id']) + "?token=" + new_token)
name = token.generate_validate_token(str(request.data['course_id']))
qr.save("./data/backend_media/invitation_qr/" + name + ".jpg")
return Response(
data={
"qrcode":
"http://" + BACKEND_DOMIAN + "/media/invitation_qr/" + name +
".jpg",
"vtk":
new_token
})
def directly_change(request):
init()
global data, headers, token
userid = token.confirm_validate_token(request.META['HTTP_TOKEN'],
expiration=600)
if userid:
usrn_obj = User.objects.get(pk=userid)
if usrn_obj.forgotten:
usrn_obj.set_password(request.data['new_pass'])
usrn_obj.forgotten = False
usrn_obj.save()
data['result'] = results['SUCCESS']
serializer = serializers.UserSerializer(usrn_obj)
data['data'] = serializer.data
return Response(data=data, headers=headers)
return Response(data=data,
headers=headers,
status=status.HTTP_403_FORBIDDEN)
def has_object_permission(self, request, view, obj):
if request.method in permissions.SAFE_METHODS:
return True
try:
vtoken = request.META['HTTP_TOKEN']
realuser = User.objects.get(
username=token.confirm_validate_token(vtoken))
teacher_list = obj.teachers
if realuser.pk in teacher_list:
return True
except:
openid = request.data['openid']
hs = encrypt.getHash(openid)
realuser = User.objects.get(wechat=hs)
teacher_list = obj.teachers
if realuser.pk in teacher_list:
return True
return False
def mutate(self, info, assignment_data):
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return DeleteAssignment(ok=False, msg=public_msg['not_login'])
try:
ids_to_del = assignment_data['ids']
del_list = []
for id in ids_to_del:
to_del = models.HWFAssignment.objects.get(pk=id)
# deadline validation
if datetime.now() > to_del.deadline.replace(tzinfo=None):
return DeleteAssignment(
ok=False,
msg=create_msg(4141,
"fail to delete ,deadline expired."))
# owner validation
if len(to_del.course_class.teachers.filter(pk=realuser.id)):
del_list.append(models.HWFAssignment.objects.get(pk=id))
models.HWFAssignment.objects.get(pk=id).delete()
else:
return DeleteAssignment(ok=False,
msg=public_msg['forbidden'])
return DeleteAssignment(ok=True,
assignments=del_list,
msg=public_msg['success'])
# bad request
except:
return DeleteAssignment(ok=False, msg=public_msg['badreq'])
def has_object_permission(self, request, view, obj):
if request.method in permissions.SAFE_METHODS:
return True
if request.method != 'PUT':
return False
else:
try:
vtoken = request.META['HTTP_TOKEN']
if token.confirm_validate_token(vtoken) == User.objects.get(
username=obj.username).username:
return True
except:
openid = request.data['openid']
hs = encrypt.getHash(openid)
try:
if hs == User.objects.get(pk=obj.pk).wechat:
return True
except:
return False
return False
def change_password(request):
init()
global data, headers, token
vtoken = request.META['HTTP_TOKEN']
userid = token.confirm_validate_token(vtoken, expiration=600)
try:
realuser = User.objects.get(pk=userid)
except:
return Response(data=data,
headers=headers,
status=status.HTTP_404_NOT_FOUND)
if realuser.check_password(request.data['old_pass']):
realuser.set_password(request.data['new_pass'])
realuser.save()
data['result'] = results['SUCCESS']
serializer = serializers.UserSerializer(realuser)
data['data'] = serializer.data
return Response(data=data, headers=headers)
else:
data['result'] = results['PWD_ERR']
return Response(data=data, headers=headers)
def mutate(self, info, score_giving_data):
# id validation
try:
realuser = token.confirm_validate_token(info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return GiveScore(ok=False, msg=public_msg['not_login'])
editing_submission = models.HWFSubmission.objects.get(pk=score_giving_data['submission'])
editing_course = editing_submission.assignment.course_class
try:
# isteacher or isassistant validation
if len(editing_course.teachers.filter(pk=realuser.id)) == 0 and len(editing_course.teaching_assistants.filter(pk=realuser.id)) == 0:
return GiveScore(ok=False, msg=public_msg['forbidden'])
else:
# deadline validation 在ddl之前不能批改作业
if datetime.now() < editing_submission.deadline.replace(tzinfo=None):
return GiveScore(ok=False, msg=create_msg(4181, '时机未到'))
editing_submission.score = score_giving_data['score']
if 'is_excellent' in score_giving_data:
editing_submission.is_excellent = score_giving_data['is_excellent']
if 'review_comment' in score_giving_data:
editing_submission.review_comment = score_giving_data['review_comment']
editing_submission.is_reviewd = True
editing_submission.save()
return GiveScore(ok=True, submission=editing_submission, msg=public_msg['success'])
# bad request
except:
return GiveScore(ok=False, msg=public_msg['badreq'])
def mutate(self, info, user_data):
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
editing_user = models.User.objects.get(pk=user_data['id'])
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
editing_user = models.User.objects.get(pk=user_data['id'])
except:
return EditUser(ok=False, msg=public_msg['not_login'])
try:
# owner validation
if editing_user.username == realuser.username:
if 'username' in user_data:
editing_user.username = user_data['username']
if 'class_number' in user_data:
editing_user.class_number = user_data['class_number']
if 'phone' in user_data:
editing_user.phone = user_data['phone']
editing_user.save()
ok = True
return EditUser(user=editing_user,
ok=ok,
msg=public_msg['success'])
else:
return EditUser(ok=False, msg=public_msg['forbidden'])
# bad request
except:
return EditUser(ok=False, msg=public_msg['badreq'])
def mutate(self, info, course_data):
is_from_wechat = False
# id validation
try:
realuser = token.confirm_validate_token(info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
editing_course = models.HWFCourseClass.objects.get(pk=course_data['id'])
except:
try:
realuser = models.User.objects.get(wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
editing_course = models.HWFCourseClass.objects.get(pk=course_data['id'])
is_from_wechat = True
except:
return EditCourse(ok=False, msg=public_msg['not_login'])
try:
# usertype validation
if is_from_wechat:
if 'students' in course_data:
student_id = course_data['students'][0]
if student_id == realuser.pk:
editing_course.students.add(models.User.objects.get(pk=student_id))
else:
return EditCourse(ok=False, msg=public_msg['forbidden'])
elif len(editing_course.teachers.filter(pk=realuser.id)) == 0:
# fk validation
pk = 0
try:
for pk in course_data.get('students', []) + course_data.get('teachers', []) + course_data.get('teaching_assistants', []):
models.User.objects.get(pk=pk)
except:
return EditCourse(ok=False, msg=create_msg(4112, "user %d cannot be found" % pk))
if len(editing_course.teaching_assistants.filter(pk=realuser.id)) == 0:
# neither assistant nor teacher
return EditCourse(ok=False, msg=public_msg['forbidden'])
# is assistant
else:
if 'description' in course_data:
editing_course.description = course_data['description']
if 'marks' in course_data:
editing_course.marks = course_data['marks']
if 'students' in course_data:
for student_id in course_data['students']:
editing_course.students.add(models.User.objects.get(pk=student_id))
if 'school' in course_data:
editing_course.school = course_data['school']
if 'start_time' in course_data:
editing_course.start_time = course_data['start_time']
if 'end_time' in course_data:
editing_course.end_time = course_data['end_time']
editing_course.save()
return EditCourse(ok=True, course=editing_course, msg=public_msg['success'])
# is teacher
else:
if 'name' in course_data:
editing_course.name = course_data['name']
if 'description' in course_data:
editing_course.description = course_data['description']
if 'marks' in course_data:
editing_course.marks = course_data['marks']
if 'teachers' in course_data:
for teacher_id in course_data['teachers']:
editing_course.teachers.add(models.User.objects.get(pk=teacher_id))
if 'teaching_assistants' in course_data:
for teaching_assistant_id in course_data['teaching_assistants']:
editing_course.teaching_assistants.add(models.User.objects.get(pk=teaching_assistant_id))
if 'students' in course_data:
for student_id in course_data['students']:
editing_course.students.add(models.User.objects.get(pk=student_id))
if 'school' in course_data:
editing_course.school = course_data['school']
if 'start_time' in course_data:
editing_course.start_time = course_data['start_time']
if 'end_time' in course_data:
editing_course.end_time = course_data['end_time']
editing_course.save()
return EditCourse(ok=True, course=editing_course, msg=public_msg['success'])
# bad request
except:
return EditCourse(ok=False, msg=public_msg['badreq'])
def mutate(self, info, assignment_data):
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
editing_assignment = models.HWFAssignment.objects.get(
pk=assignment_data['id'])
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
editing_assignment = models.HWFAssignment.objects.get(
pk=assignment_data['id'])
except:
return EditAssignment(ok=False, msg=public_msg['not_login'])
try:
# time validation
if datetime.now() > editing_assignment.deadline.replace(
tzinfo=None):
return EditAssignment(ok=False,
msg=create_msg(4151, "该作业截止日期已过，无法修改"))
# owner validation
if len(
editing_assignment.course_class.teachers.filter(
pk=realuser.id)) == 0 or len(
editing_assignment.course_class.
teaching_assistants.filter(pk=realuser.id)) == 0:
return EditAssignment(ok=False, msg=public_msg['forbidden'])
else:
# file validation
fid = 0
try:
for fid in addfile:
models.HWFFile.objects.get(fid)
except:
return EditAssignment(ok=False,
msg=create_msg(
4103,
"file %d cannot be found" % fid))
if 'name' in assignment_data:
editing_assignment.name = assignment_data['name']
if 'description' in assignment_data:
editing_assignment.description = assignment_data[
'description']
# type validation
if 'assignment_type' in assignment_data:
if assignment_data['assignment_type'] in ('image', 'docs',
'vary'):
editing_assignment.type = assignment_data[
'assignment_type']
else:
return EditAssignment(
ok=False,
msg=create_msg(
4101, "\"%s\" is not a valid assignment type" %
assignment_data['assignment_type']))
if 'addfile' in assignment_data:
for file_id in assignment_data['addfile']:
editing_assignment.addfile.add(
models.HWFFile.objects.get(pk=file_id))
if 'deadline' in assignment_data:
editing_assignment.deadline = assignment_data['deadline']
editing_assignment.save()
return EditAssignment(ok=True,
assignment=editing_assignment,
msg=public_msg['success'])
# bad request
except:
return EditAssignment(ok=False, msg=public_msg['badreq'])
def perform_create(self, serializer):
user_token = self.request.META['HTTP_TOKEN']
realuser = models.User.objects.get(
username=token.confirm_validate_token(user_token))
serializer.save(teachers=[realuser])
def mutate(self, info, course_data):
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return CreateCourse(ok=False, msg=public_msg['not_login'])
try:
# start end time validation
start_time = course_data['start_time']
end_time = course_data['end_time']
if start_time >= end_time or end_time.replace(
tzinfo=None) <= datetime.now():
return CreateCourse(
ok=False,
msg=create_msg(
4111,
"the start time \"%s\" is later than the end time \"%s\""
% (start_time, end_time)))
# isteacher validation
if realuser.usertype.lower() == 'teacher':
teachers = course_data.pop('teachers', [])
assistants = course_data.pop('teaching_assistants', [])
students = course_data.pop('students', [])
# fk validation
pk = 0
try:
for pk in teachers + assistants + students:
models.User.objects.get(pk=pk)
except:
return CreateCourse(ok=False,
msg=create_msg(
4112,
"user %d cannot be found" % pk))
serial = serializers.HWFCourseClassSerializer(data=course_data)
if serial.is_valid():
new_course = serial.save()
new_course.teachers.add(realuser)
for item in teachers:
new_course.teachers.add(
models.User.objects.get(pk=item))
for item in students:
new_course.students.add(
models.User.objects.get(pk=item))
for item in assistants:
new_course.teaching_assistants.add(
models.User.objects.get(pk=item))
return CreateCourse(ok=True,
course=new_course,
msg=public_msg['success'])
else:
return CreateCourse(ok=False, msg=public_msg['forbidden'])
# bad request
except Exception as e:
print(e)
return CreateCourse(ok=False, msg=public_msg['badreq'])
def perform_create(self, serializer):
vtk = self.request.headers['token']
userid = token.confirm_validate_token(vtk)
serializer.save(user=userid)
def mutate(self, info, submission_data):
global aware_vector
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
print('wechat valid')
except:
return EditSubmission(ok=False, msg=public_msg['not_login'])
editing_submission = models.HWFSubmission.objects.get(
pk=submission_data['id'])
try:
# type validation
if 'addfile' in submission_data:
if editing_submission.assignment.assignment_type == 'image':
return EditSubmission(
ok=False,
msg=create_msg(
4121,
"submission of image type are not allowed to obtain an \"addfile\" field"
))
# time validation
if datetime.now() > editing_submission.assignment.deadline.replace(
tzinfo=None):
return EditSubmission(
ok=False, msg=create_msg(4122, "deadline expired"))
# owner validation
if editing_submission.submitter.pk != realuser.pk:
return EditSubmission(ok=False, msg=create_msg(4191, "it's not your homework"))
if 'image' in submission_data:
# file validation
fid = 0
try:
for fid in submission_data['image']:
models.HWFFile.objects.get(pk=fid)
except:
return EditSubmission(ok=False, msg=create_msg(4103, "file %d cannot be found" % fid))
aware_vector[0] = 0
editing_submission.aware = False
if 'addfile' in submission_data:
# file validation
fid = 0
try:
for fid in submission_data['addfile']:
models.HWFFile.objects.get(pk=fid)
except:
return EditSubmission(ok=False, msg=create_msg(4103, "file %d cannot be found" % fid))
aware_vector[1] = 0
editing_submission.aware = False
editing_submission.save()
if 'description' in submission_data:
editing_submission.description = submission_data['description']
editing_submission.save()
if 'image' in submission_data:
convert_thread = Thread(
target=generate_pdf_for_submission,
args=(submission_data['image'], editing_submission.pk,
realuser, submission_data.get('enhance', False)))
convert_thread.setDaemon(False)
convert_thread.start()
if 'addfile' in submission_data:
zip_thread = Thread(
target=zip_files_for_submission,
args=(submission_data['addfile'], editing_submission.pk,
realuser))
zip_thread.setDaemon(False)
zip_thread.start()
return EditSubmission(
ok=True,
submission=editing_submission,
msg=public_msg['success'])
except:
return EditSubmission(ok=False, msg=public_msg['badreq'])
def user_list(request):
init()
global token, data, headers
# 用户列表接口
if request.method == 'GET':
# queryset = User.objects.all()
# try:
# keywords = request.query_params['keywords']
# queryset = [obj for obj in queryset if keywords in obj.username or keywords in obj.bupt_id or keywords in obj.name or keywords in obj.email or keywords in obj.phone or keywords in obj.wechat or keywords in obj.class_number]
# except:
# pass
# serializer = serializers.UserSerializer(
# queryset, many=True)
# data['data'] = serializer.data
# data['result'] = results['SUCCESS']
# return Response(data=data, headers=headers)
try:
try:
# 只有登录了才能看哦
if token.confirm_validate_token(request.META['HTTP_TOKEN']):
headers['isLogin'] = True
headers['authed'] = True
queryset = User.objects.all()
try:
keywords = request.query_params['keywords']
queryset = [
obj for obj in queryset
if keywords in obj.username or keywords in
obj.bupt_id or keywords in obj.name or keywords in
obj.email or keywords in obj.phone or keywords in
obj.wechat or keywords in obj.class_number
]
except:
pass
serializer = serializers.UserSerializer(queryset,
many=True)
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
except:
openid = request.META['HTTP_TOKEN']
hs = encrypt.getHash(openid)
if User.objects.get(wechat=hs):
queryset = User.objects.all()
try:
keywords = request.query_params['keywords']
queryset = [
obj for obj in queryset
if keywords in obj.username or keywords in
obj.bupt_id or keywords in obj.name or keywords in
obj.email or keywords in obj.phone or keywords in
obj.wechat or keywords in obj.class_number
]
except:
pass
serializer = serializers.UserSerializer(queryset,
many=True)
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
except:
data['result'] = results['EXPIRED']
headers['expired'] = True
return Response(headers=headers, data=data)
else:
return Response(headers=headers,
data=data,
status=status.HTTP_403_FORBIDDEN)
data = {'result': {'code': None, 'msg': None}, 'data': None}
headers = {'isLogin': False, 'authed': False}
# 注册接口
if request.method == 'POST':
request.data['useravatar'] = [
2,
]
serializer = serializers.UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
data['result'] = results['SUCCESS']
send_confirm(User.objects.get(email=request.data['email']))
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk):
init()
global token, data, headers
try:
user = User.objects.get(pk=pk)
except:
try:
user = User.objects.get(phone=pk)
except:
try:
user = User.objects.get(bupt_id=pk)
except:
try:
user = User.objects.get(wechat=pk)
except:
return Response(data=data,
headers=headers,
status=status.HTTP_404_NOT_FOUND)
# 获取单个用户信息接口
# 登录才能看哦
if request.method == 'GET':
try:
try:
token.confirm_validate_token(request.META['HTTP_TOKEN'])
headers['isLogin'] = True
headers['authed'] = True
serializer = serializers.UserSerializer(user)
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
except:
openid = request.META['HTTP_TOKEN']
hs = encrypt.getHash(openid)
User.objects.get(wechat=hs)
headers['isLogin'] = True
headers['authed'] = True
serializer = serializers.UserSerializer(user)
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
except:
try:
found_user = User.objects.get(pk=pk)
serializer = serializers.UserSerializer(found_user)
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
except:
data['result'] = results['EXPIRED']
headers['expired'] = True
return Response(headers=headers, data=data)
else:
return Response(data=data,
headers=headers,
status=status.HTTP_403_FORBIDDEN)
# 修改用户信息接口
# 只有自己才能改哦
elif request.method == 'PUT':
try:
try:
plain = token.confirm_validate_token(
request.META['HTTP_TOKEN'])
except:
openid = request.META['HTTP_TOKEN']
found_user = User.objects.get(pk=pk)
found_user.wechat = encrypt.getHash(openid)
found_user.save()
data['result'] = results['SUCCESS']
data['data'] = serializers.UserSerializer(found_user).data
return Response(data=data, headers=headers)
else:
try:
found_user = User.objects.get(pk=plain)
except:
return Response(data=data,
headers=headers,
status=status.HTTP_404_NOT_FOUND)
except SignatureExpired as e:
data['result'] = results['EXPIRED']
headers['expired'] = True
return Response(headers=headers, data=data)
headers['isLogin'] = True
if found_user == user:
headers['authed'] = True
serializer = serializers.UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
data['data'] = serializer.data
data['result'] = results['SUCCESS']
return Response(data=data, headers=headers)
else:
return Response(data=data,
headers=headers,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(data=data,
headers=headers,
status=status.HTTP_403_FORBIDDEN)
def mutate(self, info, assignment_data):
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
except:
return CreateAssignment(ok=False, msg=public_msg['not_login'])
try:
# type validation
if assignment_data['assignment_type'] not in ('image', 'docs',
'vary'):
return CreateAssignment(
ok=False,
msg=create_msg(
4101, "\"%s\" is not a valid assignment type" %
assignment_data['assignment_type']))
# time validation
if assignment_data['deadline'].replace(
tzinfo=None) < datetime.now():
return CreateAssignment(ok=False,
msg=create_msg(
4102,
"\"%s\" is an expired datetime" %
assignment_data['deadline']))
editing_course = models.HWFCourseClass.objects.get(
pk=assignment_data['course_class'])
if datetime.now() > editing_course.end_time.replace(tzinfo=None):
return CreateAssignment(ok=False,
msg=create_msg(
4102,
"\"%s\" is an expired datetime" %
assignment_data['deadline']))
# isteacher or isassistant validation
if len(editing_course.teachers.filter(
pk=realuser.id)) == 0 and len(
editing_course.teaching_assistants.filter(
pk=realuser.id)) == 0:
return CreateAssignment(ok=False, msg=public_msg['forbiddren'])
else:
addfile = assignment_data.pop('addfile', [])
# file validation
fid = 0
try:
for fid in addfile:
models.HWFFile.objects.get(fid)
except:
return CreateAssignment(
ok=False,
msg=create_msg(4103, "file %d cannot be found" % fid))
serial = serializers.HWFAssignmentSerializer(
data=assignment_data)
if serial.is_valid():
new_assignment = serial.save()
for item in addfile:
new_assignment.addfile.add(item)
return CreateAssignment(ok=True,
assignment=new_assignment,
msg=public_msg['success'])
# bad request
except Exception as e:
print(e)
return CreateAssignment(ok=False, msg=public_msg['badreq'])
def mutate(self, info, submission_data):
global aware_vector
# id validation
try:
realuser = token.confirm_validate_token(
info.context.META['HTTP_TOKEN'])
realuser = models.User.objects.get(pk=realuser)
except:
try:
realuser = models.User.objects.get(
wechat=encrypt.getHash(info.context.META['HTTP_TOKEN']))
print('wechat valid')
except:
return CreateSubmission(ok=False, msg=public_msg['not_login'])
try:
# type validation
if 'addfile' in submission_data:
if models.HWFAssignment.objects.get(
pk=submission_data['assignment']
).assignment_type == 'image':
return CreateSubmission(
ok=False,
msg=create_msg(
4121,
"submission of image type are not allowed to obtain an \"addfile\" field"
))
# time validation
if datetime.now() > models.HWFAssignment.objects.get(
pk=submission_data['assignment']).deadline.replace(
tzinfo=None):
return CreateSubmission(ok=False,
msg=create_msg(4122,
"deadline expired"))
viewing_course = models.HWFAssignment.objects.get(
pk=submission_data['assignment']).course_class
# is authentic student
if len(viewing_course.students.filter(pk=realuser.pk)) == 0:
return CreateSubmission(
ok=False,
msg=create_msg(4123,
"you are not a student of this course"))
if 'image' in submission_data:
# file validation
fid = 0
try:
for fid in submission_data['image']:
models.HWFFile.objects.get(pk=fid)
except:
return CreateSubmission(
ok=False,
msg=create_msg(4103, "file %d cannot be found" % fid))
aware_vector[0] = 0
if 'addfile' in submission_data:
# file validation
fid = 0
try:
for fid in submission_data['addfile']:
models.HWFFile.objects.get(pk=fid)
except:
return CreateSubmission(
ok=False,
msg=create_msg(4103, "file %d cannot be found" % fid))
aware_vector[1] = 0
new_submission = models.HWFSubmission.objects.create(
description=submission_data['description'],
assignment_id=submission_data['assignment'],
submitter_id=realuser.pk)
if 'image' in submission_data:
convert_thread = Thread(
target=generate_pdf_for_submission,
args=(submission_data['image'], new_submission.pk,
realuser, submission_data.get('enhance', False)))
convert_thread.setDaemon(False)
convert_thread.start()
if 'addfile' in submission_data:
zip_thread = Thread(target=zip_files_for_submission,
args=(submission_data['addfile'],
new_submission.pk, realuser))
zip_thread.setDaemon(False)
zip_thread.start()
return CreateSubmission(ok=True,
submission=new_submission,
msg=public_msg['success'])
# bad request
except Exception as e:
print(e)
return CreateSubmission(ok=False, msg=public_msg['badreq'])
