def extra(self, request, detail):
response = True
params = request.data
curriculum = detail['curriculum']
try:
if 'lid' in params:
curri = Curriculum.objects.filter(cls=curriculum.cls,
lesson=params['lid'])
if curri.exists():
return ResponseContent(code=401,
token=request.auth,
description=10142,
error=10142)
courses = ClsCourse.objects.filter(
cls=params['oid'],
course__LessonCourse=params['lid'],
teacher=request.user.id)
if not courses.exists():
return ResponseContent(code=401,
token=request.auth,
description=10601,
error=10601)
except Exception as e:
return ResponseContent(code=604,
token=request.auth,
description=10523,
error=e.__str__())
return response
def extra(self, request, detail):
response = True
params = request.data
question = detail['question']
homework = question.homework
gametype = question.gametype
gcid = question.gcid
gsid = question.gsid
idx = question.idx
if 'gametype' in params:
gametype = params['gametype']
if 'gcid' in params:
gcid = params['gcid']
# if 'gsid' in params:
# gsid = params['gsid']
if 'idx' in params:
idx = params['idx']
try:
question = HomeworkDetail.objects.filter(
id=params['qid'],
homework__curriculum__lesson__course__ClsCourseCourse__teacher=
request.user.id)
if not question.exists():
return ResponseContent(code=401,
token=request.auth,
description=10602,
error=10602)
# if 'gametype' in params or 'gcid' in params or 'gsid' in params:
if 'gametype' in params or 'gcid' in params:
condition = Q(homework=homework) & Q(gametype=gametype) & Q(
gcid=gcid)
question = HomeworkDetail.objects.filter(condition)
if question.exists():
return ResponseContent(code=401,
token=request.auth,
description=10143,
error=10143)
if 'idx' in params:
condition = Q(homework=homework) & Q(idx=idx)
question = HomeworkDetail.objects.filter(condition)
if question.exists():
return ResponseContent(code=401,
token=request.auth,
description=10600,
error=10600)
except Exception as e:
return ResponseContent(code=602,
description=10542,
error=e.__str__())
def match_scene(self, params):
response = True
scene = int(params['scene'])
profile = UserTeachingProfile.objects.filter(phone=params['phone'])
if scene == 1 and profile.exists():
response = ResponseContent(code=401, description=10105, error=10105)
if scene != 1 and (not profile.exists()):
response = ResponseContent(code=401, description=10104, error=10104)
return response
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=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=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=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=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=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 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(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=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=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 extra(self, request, detail):
response = True
params = request.data
try:
courses = ClsCourse.objects.filter(cls=params['oid'],
course=params['cid'],
teacher=request.user.id)
if not courses.exists():
return ResponseContent(code=401,
description=10601,
error=10601)
except Exception as e:
return ResponseContent(code=602,
description=10559,
error=e.__str__())
return response
def auth(self, request, user, password):
response = True
user = authenticate(username=user.username, password=password)
if user is None:
response = ResponseContent(code=401,
description=10103,
error=10103)
elif user is not None:
login_init(user)
if user.is_active:
login(request, user)
else:
response = ResponseContent(code=601,
description=10150,
error=10150)
return response
def match_params(self, params):
response = True
for key, value in self.check_list.items():
if key in params:
match = getattr(self, value)
if not match(params[key]):
response = ResponseContent(code=401, description=10101, error=key + '不正确')
break
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_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_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_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_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_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 refresh_login(self, request, profile):
response = True
try:
profile = UserTeachingProfile.objects.filter(id=profile.id).update(
login_time=timezone.now(),
ip=request.META.get('REMOTE_ADDR')
)
except Exception as e:
response = ResponseContent(code=602, description=10816, 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_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_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 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_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