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=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=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=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(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(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 match_sms_captcha(self, params, scene):
account = None
if 'phone' in params:
account = params['phone']
elif 'account' in params:
account = params['account']
sms_code = params['smsCode']
response = ResponseContent(code=401, description=10704, error=10704)
try:
sms = SMS.objects.filter(phone=account)
if sms.exists():
sms = sms.first()
if sms.used != 0:
response.refresh(code=401, description=10700, error=10700)
if sms.scene != int(scene):
response.refresh(code=401, description=10701, error=10701)
elif datetime.now() - sms.end_time.replace(tzinfo=None) > timedelta(hours=24):
response.refresh(code=401, description=10702, error=10702)
elif sms_code != sms.secret:
response.refresh(code=401, description=10703, error=10703)
else:
sms.used = 1
sms.save()
response = True
except Exception as e:
response.refresh(code=602, description=10803, error=e.__str__())
return response
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 exist_mao_record(self, params):
response = ResponseContent(code=401, description=10149, error=10149)
try:
record = MaoRecord.objects.filter(id=params['mrcid'])
if record.exists():
response = record.first()
except Exception as e:
response.refresh(code=602, description=10817, error=e.__str__())
return response
def exist_enroll(self, params):
response = ResponseContent(code=401, description=10116, error=10116)
try:
enroll = ClsStudent.objects.filter(id=params['eid'])
if enroll.exists():
response = enroll.first()
except Exception as e:
response.refresh(code=602, description=10812, error=e.__str__())
return response
def exist_homework(self, params):
response = ResponseContent(code=401, description=10114, error=10114)
try:
homework = Homework.objects.filter(id=params['hid'])
if homework.exists():
response = homework.first()
except Exception as e:
response.refresh(code=602, description=10810, error=e.__str__())
return response
def exist_question(self, params):
response = ResponseContent(code=401, description=10118, error=10118)
try:
question = HomeworkDetail.objects.filter(id=params['qid'])
if question.exists():
response = question.first()
except Exception as e:
response.refresh(code=602, description=10814, error=e.__str__())
return response
def exist_comment(self, params):
response = ResponseContent(code=401, description=10120, error=10120)
try:
comment = Comment.objects.filter(id=params['comment'])
if comment.exists():
response = comment.first()
except Exception as e:
response.refresh(code=602, description=10816, error=e.__str__())
return response
def exist_lesson(self, params):
response = ResponseContent(code=401, description=10113, error=10113)
try:
lesson = Lesson.objects.filter(id=params['lid'])
if lesson.exists():
response = lesson.first()
except Exception as e:
response.refresh(code=602, description=10809, error=e.__str__())
return response
def exist_course(self, params):
response = ResponseContent(code=401, description=10112, error=10112)
try:
course = Course.objects.filter(id=params['cid'])
if course.exists():
response = course.first()
except Exception as e:
response.refresh(code=602, description=10808, error=e.__str__())
return response
def exist_class(self, params):
response = ResponseContent(code=401, description=10111, error=10111)
try:
organization = Cls.objects.filter(id=params['oid'])
if organization.exists():
response = organization.first()
except Exception as e:
response.refresh(code=602, description=10807, error=e.__str__())
return response
def exist_curriculum(self, params):
response = ResponseContent(code=401, description=10117, error=10117)
try:
curriculum = Curriculum.objects.filter(id=params['curid'])
if curriculum.exists():
response = curriculum.first()
except Exception as e:
response.refresh(code=602, description=10813, error=e.__str__())
return response
def exist_user(self, params):
response = ResponseContent(code=401, description=10104, error=10104)
try:
user = User.objects.filter(id=params['user'])
if user.exists():
response = user.first()
except Exception as e:
response.refresh(code=602, description=10558, error=e.__str__())
return response
def exist_example(self, params):
response = ResponseContent(code=401, description=10119, error=10119)
try:
example = LessonDetail.objects.filter(id=params['leid'])
if example.exists():
response = example.first()
except Exception as e:
response.refresh(code=602, description=10815, error=e.__str__())
return response
def exist_plan(self, params):
response = ResponseContent(code=401, description=10115, error=10115)
try:
plan = ClsCourse.objects.filter(id=params['pid'])
if plan.exists():
response = plan.first()
except Exception as e:
response.refresh(code=602, description=10811, error=e.__str__())
return response
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 exist_student(self, params):
response = ResponseContent(code=401, description=10106, error=10106)
try:
stundent = None
if 'student' in params:
stundent = params['student']
if 'sid' in params:
stundent = params['sid']
student = UserTeachingProfile.objects.filter(user=stundent, role=0)
if student.exists():
response = student.first()
except Exception as e:
response.refresh(code=602, description=10806, error=e.__str__())
return response
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 exist_teacher(self, params):
response = ResponseContent(code=401, description=10108, error=10108)
# manager = UserTeachingProfile.objects.filter(id=params['mid']).exclude(Q(role=0) | Q(role=1) | Q(role=2)).first()
try:
teacher = None
if 'teacher' in params:
teacher = params['teacher']
if 'tid' in params:
teacher = params['tid']
teacher = UserTeachingProfile.objects.filter(user=teacher).exclude(role=0)
if teacher.exists():
response = teacher.first()
except Exception as e:
response.refresh(code=602, description=10805, error=e.__str__())
return response
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)
