def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12035)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
question = []
if 'hid' in params:
question = HomeworkDetail.objects.filter(
homework=params['hid'],
homework__curriculum__lesson__course__ClsCourseCourse__teacher
=request.user.id,
).order_by('idx')
elif 'oid' in params and 'lid' in params:
question = HomeworkDetail.objects.filter(
homework__curriculum__cls=params['oid'],
homework__curriculum__lesson=params['lid'],
homework__curriculum__lesson__course__ClsCourseCourse__teacher
=request.user.id,
).order_by('idx')
serializer = QuestionSerializer(question, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10533, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12053)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
recode = MaoRecord.objects.filter(
stage=request.data['gsid'],
user=params['student']).order_by('judge_time')
serializer = MaoRecordSerializer(recode, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(mark=True,
code=602,
description=10556,
error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12032)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
condition = Q(
curriculum__lesson__course__ClsCourseCourse__teacher=request.
user.id)
if 'oid' in params:
condition = condition & Q(curriculum__cls=params['oid'])
if 'lid' in params:
condition = condition & Q(curriculum__lesson=params['lid'])
homework = Homework.objects.filter(condition)
serializer = HomeworkSerializer(homework, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10530, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12046)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
enroll = ClsStudent.objects.filter(
cls=params['oid'],
cls__clscourse__teacher=request.user.id,
)
score = MaoScore.objects.filter(stage__chapter=params['gcid'])
stage = MaoGameStage.objects.filter(
chapter=params['gcid']).order_by('idx')
response.data['student'] = EnrollSerializer(enroll, many=True).data
response.data['score'] = HighScoreSerializer(score, many=True).data
response.data['stage'] = MaoGameStageSerializer(stage,
many=True).data
except Exception as e:
response.refresh(code=604, description=10544, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12033)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
serializer = HomeworkSerializer(data=self.formatData(request),
partial=True)
if serializer.is_valid():
serializer.save()
serializer = CurriculumSerializer(detail['curriculum'],
data=self.formatData(request),
partial=True)
if serializer.is_valid():
serializer.save()
else:
response.refresh(code=11001,
description=11001,
error=serializer.errors)
state = status.HTTP_501_NOT_IMPLEMENTED
else:
response.refresh(code=11001,
description=10531,
error=serializer.errors)
state = status.HTTP_501_NOT_IMPLEMENTED
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(mark=False,
code=200,
token=request.auth,
description=12002)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
serializer = UserSerializer(
detail['user'],
data={'password': request.data['password']},
partial=True)
if serializer.is_valid():
serializer.save()
else:
response.refresh(code=601,
description=12002,
error=serializer.errors)
state = status.HTTP_501_NOT_IMPLEMENTED
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12023)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
params = request.data
try:
curriculum = Curriculum.objects.filter(
cls=params['oid'],
lesson__course=params['cid'],
lesson__course__ClsCourseCourse__teacher=request.user.id)
serializer = CurriculumSerializer(curriculum, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10521, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12053)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
openStatus = False
try:
enroll = ClsStudent.objects.filter(
cls=params['oid'],
cls__clscourse__teacher=request.user.id,
)
if enroll.exists():
for item in enroll:
result = mao_chapter_unlock(item.student, params['gcid'])
if result:
openStatus = result
else:
response.refresh(code=11001, description=10153, error=10153)
except Exception as e:
response.refresh(code=602, description=10560, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
response.data = openStatus
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12043)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
if int(params['enable']) == 2:
example = LessonDetail.objects.filter(
lesson=params['lid'],
lesson__course__ClsCourseCourse__teacher=request.user.id,
).order_by('idx')
else:
example = LessonDetail.objects.filter(
lesson=params['lid'],
enable=params['enable'],
lesson__course__ClsCourseCourse__teacher=request.user.id,
).order_by('idx')
serializer = ExampleSerializer(example, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10541, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12017)
state = status.HTTP_200_OK
detail = self.readiness(request)
result = {}
count = 0
formerly = 0
refreshName = 0
add = 0
surplus = 0
try:
users = User.objects.all()
count = len(users)
for user in users:
if not hasattr(user, 'userteachingprofile'):
role = 0
if user.is_superuser > 0:
role = 100
serializer = UserProfileSerializer(data={
'name':
user.first_name + user.last_name,
'role':
role,
'user':
user.id
},
partial=True)
if serializer.is_valid():
serializer.save()
add += 1
else:
result[user.username] = serializer.errors
surplus += 1
else:
formerly += 1
if user.first_name + user.last_name:
serializer = UserProfileSerializer(
user.userteachingprofile,
data={
'name': user.first_name + user.last_name,
},
partial=True)
if serializer.is_valid():
serializer.save()
response.data = {
'count': count,
'formerly': formerly,
'add': add,
'surplus': surplus,
'reason': result
}
except Exception as e:
response.refresh(code=604, description=10551, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def get_list(self, request, pk=None):
response = ResponseContent(code=200,
token=request.auth,
description=self.success_code['get'])
state = status.HTTP_200_OK
instance = self.get_object()
serializer = self.get_serializer(instance, many=True)
response.data = serializer.data
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200, description=12054)
state = status.HTTP_200_OK
logout(request)
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(request.user)
token = jwt_encode_handler(payload)
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12017)
state = status.HTTP_200_OK
try:
calss_list = Cls.objects.filter(students=request.user.id, enable=1)
serializer = ClassSerializer(calss_list, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10515, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def add_instance(self, request, pk=None):
response = ResponseContent(code=200,
token=request.auth,
description=self.success_code['post'])
state = status.HTTP_200_OK
serializer = self.get_serializer(data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
else:
response.refresh(code=604,
description=self.fail_code['post'],
error=serializer.errors)
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12053)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
student = detail['student']
result = mao_chapter_unlock(student.user, params['gcid'])
response.data = result
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12020)
state = status.HTTP_200_OK
detail = self.readiness(request)
try:
lessons = Lesson.objects.filter(course=request.data['cid'],
enable=1)
serializer = LessonSerializer(lessons, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10518, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200, description=12003)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
sms_captcha = SMSCaptcha()
result = sms_captcha.send(request.data['phone'],
int(request.data['scene']))
if isinstance(result, ResponseContent):
response = result
if response.code > 300 or response.status == 'sms':
state = status.HTTP_200_OK
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12050)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
account = detail['account']
url = mao_access_chapter(account, request.data['gcid'])
if url:
response.data = url
else:
response.refresh(code=604, description=10553, error=10553)
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
token = self.get_jwt_token(detail['user'])
response = self.auth(request, detail['user'])
if isinstance(response, ResponseContent):
return Response(response.content(),
status=status.HTTP_401_UNAUTHORIZED)
serializer = UserProfileSerializer(detail['profile'])
response = ResponseContent(code=200,
description=12000,
token=token,
data=serializer.data)
return Response(response.content(), status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12041)
state = status.HTTP_200_OK
params = request.data
try:
if int(params['gametype']) == 0:
game_chapter = MaoGameChapter.objects.filter(enable=1)
serializer = MaoGameChapterSerializer(game_chapter, many=True)
response.data = serializer.data
elif params['gametype'] == 1:
pass
except Exception as e:
response.refresh(code=604, description=10539, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=601, description=10500)
state = status.HTTP_500_INTERNAL_SERVER_ERROR
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
params = request.data
serializer = UserSerializer(data={
'username': params['account'],
'password': params['password']
},
partial=True)
if serializer.is_valid():
user = serializer.save()
serializer = UserProfileSerializer(data={
'user': user.id,
'phone': params['account']
},
partial=True)
if serializer.is_valid():
profile = serializer.save()
token = self.get_jwt_token(user)
result = self.auth(request, user)
if isinstance(result, ResponseContent):
return Response(result.content(),
status=status.HTTP_401_UNAUTHORIZED)
response.refresh(code=200,
token=token,
description=12001,
data=serializer.data)
state = status.HTTP_200_OK
else:
response.error = serializer.errors
else:
response.error = serializer.errors
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12051)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
stages = MaoStage.objects.filter(chapter__id=request.data['gcid'])
serializer = MaoStageSerializer(stages, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=602, description=10554, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12007)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
user = detail['user']
profile = detail['profile']
if 'name' in params:
serializer = UserSerializer(user,
data={
'first_name': params['name'][0:1],
'last_name': params['name'][1:]
},
partial=True)
if serializer.is_valid():
serializer.save()
else:
response.refresh(code=601,
description=10505,
error=serializer.errors)
state = status.HTTP_500_INTERNAL_SERVER_ERROR
serializer = UserProfileSerializer(profile,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
response.data = serializer.data
else:
response.refresh(code=601,
description=10505,
error=serializer.errors)
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12017)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
course = Course.objects.filter(
ClsCourseCourse__teacher=request.user.id)
serializer = CourseSerializer(course, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10515, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12032)
state = status.HTTP_200_OK
params = request.data
data = []
detail = self.readiness(request)
try:
question = HomeworkDetail.objects.filter(
homework__curriculum__cls=params['oid'],
homework__curriculum__lesson=params['lid'],
enable=1)
serializer = QuestionSerializer(question, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(code=604, description=10533, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12004)
state = status.HTTP_200_OK
params = request.data
try:
record = MaoRecord.objects.filter(id=request.data['mrcid'])
if record.exists():
record = record.last()
response.data = {
'code': record.origin_code,
'result': record.result,
'output': record.output,
'score': record.score,
'success': record.success
}
except Exception as e:
response.refresh(code=602, description=10557, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12037)
state = status.HTTP_200_OK
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
serializer = QuestionSerializer(detail['question'],
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
else:
response.refresh(code=11001,
description=10535,
error=serializer.errors)
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(mark=False,
code=200,
token=request.auth,
description=12017)
state = status.HTTP_200_OK
params = request.data
data = []
detail = self.readiness(request)
try:
example = LessonDetail.objects.filter(lesson=params['lid'],
enable=1).order_by('idx')
serializer = ExampleSerializer(example, many=True)
response.data = serializer.data
except Exception as e:
response.refresh(mark=True,
code=604,
description=10515,
error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
def post(self, request, *args, **kwargs):
response = ResponseContent(code=200,
token=request.auth,
description=12005)
state = status.HTTP_200_OK
params = request.data
detail = self.readiness(request)
if isinstance(detail, ResponseContent):
return Response(detail.content(),
status=status.HTTP_406_NOT_ACCEPTABLE)
try:
comment = Comment.objects.filter(homework=params['hid'],
student=params['student'])
if comment.exists():
response.data = CommentSerializer(comment[0]).data
else:
response.data = {}
except Exception as e:
response.refresh(code=602, description=10503, error=e.__str__())
state = status.HTTP_500_INTERNAL_SERVER_ERROR
return Response(response.content(), status=state)
