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=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=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=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=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=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,
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)
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 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,
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=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):
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(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)
