def test_course_detail(self):
"""
Retrieve a course
"""
url = reverse('course_detail', args=[1])
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = response.json()
course_json = CourseSerializer(self.course)
self.assertEqual(response, course_json.data)
"""
Update a course
"""
data = {"tutor": 1}
response = self.client.patch(url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = response.json()
self.course.tutor = self.user
course_json = CourseSerializer(self.course)
self.assertEqual(response, course_json.data)
"""
Delete a course
"""
self.assertEqual(Course.objects.count(), 1)
self.client.delete(url)
self.assertEqual(Course.objects.count(), 0)
def put(self, request, pk):
course = get_course_or_404(pk)
if course.created_by.id != request.user.id:
return Response({"permission": "denied"}, status=status.HTTP_403_FORBIDDEN)
serializer = CourseSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if request.user.id != course.created_by.id:
return Response({"permission": "denied"}, status=status.HTTP_403_FORBIDDEN)
validated_data = serializer.data
audit_attrs = get_audit_attrs(course.created_by, request.user)
validated_data.update(audit_attrs)
previous_is_published = course.is_published
course = serializer.update(course, validated_data)
response = serializer.data
if previous_is_published != course.is_published:
#import ipdb; ipdb.set_trace()
response = dict(serializer.data)
if course.is_published:
courseslug = course.publish_and_slugify()
else:
courseslug = None
course.unpublish()
if courseslug is not None:
response['slug'] = courseslug.slug
else:
response['slug'] = None
return Response(response, status.HTTP_200_OK)
def put_course(self, ex_id: int, data: dict):
des = CourseRepository.get_course_detail(self, ex_id=ex_id)
serializer = CourseSerializer(des, data=data)
if serializer.is_valid():
serializer.save()
return CourseRepository.put_course(self, ex_id=ex_id, data=data)
return serializer.errors, status.HTTP_400_BAD_REQUEST
def createcourse(request):
course_data = JSONParser().parse(request)
course_serializer = CourseSerializer(data=course_data)
if course_serializer.is_valid():
course_serializer.save()
return JsonResponse(course_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(course_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
obj = self.get_object(pk=pk)
if obj:
ser = CourseSerializer(instance=obj, data=request.data)
if ser.is_valid():
ser.save()
return Response(data=ser.data, status=status.HTTP_200_OK)
return Response(data=ser.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(data={"msg": "没有此课程信息"},
status=status.HTTP_404_NOT_FOUND)
def post(self, request):
serializer = CourseSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
validated_data = serializer.data
audit_attrs = get_audit_attrs(request.user)
validated_data.update(audit_attrs)
course = serializer.create(validated_data)
serializer = CourseSerializer(course)
return Response(serializer.data, status.HTTP_201_CREATED)
def updatecourse(request, id):
try:
course = Course.objects.get(id=id)
except Course.DoesNotExist:
return JsonResponse({'message': 'The tutorial does not exist'},
status=status.HTTP_404_NOT_FOUND)
course_data = JSONParser().parse(request)
course_serializer = CourseSerializer(course, data=course_data)
if course_serializer.is_valid():
course_serializer.save()
return JsonResponse(course_serializer.data)
return JsonResponse(course_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(request, cou_id):
try:
cou = course.objects.get(pk=cou_id)
except cou.DoesNotExist:
errors = "Error!"
return HttpResponse(status=400)
# if request.method == 'GET':
# serializer = CourseSerializer(cou)
# return JSONResponse(serializer.data)
data = JSONParser().parse(request)
serializer = CourseSerializer(cou, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
def put(self, request, *args, **kwargs):
user = request.user
data = request.data
pk = kwargs['pk']
course = get_object_or_404(Course, pk=pk)
if not course.is_authorized(request.user):
return Response(status=401)
content = course.description
content_data = {
'text': data['text'],
"last_edited_at": datetime.datetime.now()
}
if "file" in request.FILES:
file = request.FILES['file']
content_data['file'] = file
serializer = ContentSerializer(content, data=content_data)
serializer.is_valid(raise_exception=True)
serializer.save()
course_data = {
"title": data['title'],
"owner": course.owner.pk,
"description": course.description.pk,
"last_edited_at": datetime.datetime.now()
}
serializer = CourseSerializer(course, data=course_data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=HTTP_200_OK)
def get(self, request, pk):
obj = self.get_object(pk=pk)
if obj:
ser = CourseSerializer(instance=obj)
return Response(data=ser.data, status=status.HTTP_200_OK)
return Response(data={"msg": "没有此课程信息"},
status=status.HTTP_404_NOT_FOUND)
class QuizSerializer(serializers.ModelSerializer):
course = CourseSerializer(read_only=True)
class Meta:
model = Quiz
fields = '__all__'
read_only_fields = ['pk']
def courses(self, request, pk):
sort = request.GET.get('sort', '')
filter = request.GET.get('filter', '')
if pk != 'all':
course_info = CourseInfo.objects.filter(category_id=pk, active=1)
else:
course_info = CourseInfo.objects.filter(active=1)
if 'free' in filter:
course_info = course_info.filter(money=0)
if 'update_at' in sort:
course_list = course_info.order_by('-start_time')
else:
course_list = course_info.order_by('-create_time')
if 'sales' in sort:
course_info = []
for i in course_list:
count = MyCourse.objects.filter(course_id=i.course_id).count()
course_info.append({'course_id': i.course_id, 'count': count})
course_info.sort(key=lambda k: (k.get('count', 0)), reverse=True)
course_list = []
for c in course_info:
course = CourseInfo.objects.get(course_id=c['course_id'])
course_list.append(course)
if 'selection' in sort:
course_list = course_info.filter(select_status=SELECT_STATUS_ON)
page = self.paginate_queryset(course_list)
serializer = CourseSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_Course_get_valid_single(self):
url = reverse('CourseDetailUrl', kwargs={'pk': self.course.pk})
response = client.get(url)
course = Course.objects.get(pk=self.course.pk)
serializer = CourseSerializer(course)
assert response.data == serializer.data
assert response.status_code == status.HTTP_200_OK
class StudentCourseSerializer(serializers.ModelSerializer):
"""Student's Course model serializer."""
course = CourseSerializer(required=False)
class Meta:
model = StudentCourse
fields = '__all__'
def getcourses(request):
courses = Course.objects.all()
title = request.GET.get('title', None)
if title is not None:
courses = courses.filter(title__icontains=title)
courses_serializer = CourseSerializer(courses, many=True)
return JsonResponse(courses_serializer.data, safe=False)
def test_get_courses(self):
self.client.credentials(HTTP_AUTHORIZATION='')
url = reverse('course_list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = response.json()
course_json = CourseSerializer(self.course)
self.assertEqual(response[0], course_json.data)
def course_detail(request, pk):
"""
获取、更新、删除单条课程
:param request:
:param pk:
:return:
"""
try:
course = Course.objects.get(pk=pk)
except Course.DoesNotExist:
return Response(data={"msg": "没有此课程信息"},
status=status.HTTP_404_NOT_FOUND)
else:
if request.method == "GET":
ser = CourseSerializer(instance=course)
return Response(data=ser.data, status=status.HTTP_200_OK)
elif request.method == "PUT":
ser = CourseSerializer(instance=course, data=request.data)
if ser.is_valid():
ser.save()
return Response(data=ser.data, status=status.HTTP_200_OK)
return Response(data=ser.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == "DELETE":
course.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, format=None):
try:
course_name = request.GET['coursename']
courses = Course.objects.filter(name__icontains=course_name)
except KeyError:
return Response(status=status.HTTP_400_BAD_REQUEST)
serializer = CourseSerializer(courses, many=True)
return Response(serializer.data)
class AchievementSerializer(serializers.ModelSerializer):
"""Achievement model serializer."""
related_courses = CourseSerializer(required=False, many=True)
related_educators = EducatorSerializer(required=False, many=True)
related_students = StudentSerializer(required=False, many=True)
related_parents = ParentSerializer(required=False, many=True)
class Meta:
model = Achievement
fields = '__all__'
def getmycourse(request, id):
try:
course = Course.objects.get(id=id)
except Course.DoesNotExist:
return JsonResponse({'message': 'The tutorial does not exist'},
status=status.HTTP_404_NOT_FOUND)
course_serializer = CourseSerializer(course)
return JsonResponse(course_serializer.data)
def get(self, request, format=None):
try:
course_name = request.GET['coursename']
course = Course.objects.get(name=course_name)
except KeyError:
return Response(status=status.HTTP_400_BAD_REQUEST)
except Course.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = CourseSerializer(course)
return Response(serializer.data)
class StudentSerializer(serializers.ModelSerializer):
#courses = serializers.RelatedField(source='course', read_only=True)
# courses = serializers.PrimaryKeyRelatedField(
# queryset=Course.objects.all(), many=True)
#course = serializers.ManyRelatedField(child_relation=Course.objects.all())
courses = CourseSerializer(many=True, read_only=True)
class Meta:
model = Student
fields = ('id', 'name', 'courses')
def get(self, request):
"""
查询历史课程
"""
data = {}
id = request.GET.get('id', None)
if id is not None:
course = get_object_or_404(Course, id=id)
serializer = CourseSerializer(course)
return JsonResponse({"courses": [serializer.data]}, safe=False)
student_username = request.GET.get('student_username', None)
if student_username is not None:
student = get_object_or_404(Student, user__username=student_username)
courses = student.courses.all()
serializer = CourseSerializer(courses, many=True)
return JsonResponse({"courses": serializer.data}, safe=False)
teacher_username = request.GET.get('teacher_username', None)
if teacher_username is not None:
teacher = get_object_or_404(Teacher, user__username=teacher_username)
courses = teacher.courses.all()
serializer = CourseSerializer(courses, many=True)
return JsonResponse({"courses": serializer.data}, safe=False)
cm_username = request.GET.get('cm_username', None)
if cm_username is not None:
cm = get_object_or_404(CM, user__username=cm_username)
courses = cm.courses.all()
serializer = CourseSerializer(courses, many=True)
return JsonResponse({"courses": serializer.data}, safe=False)
offering_course_id = request.GET.get('offering_course_id', None)
if offering_course_id is not None:
courses = Course.objects.filter(offering_course=offering_course_id)
serializer = CourseSerializer(courses, many=True)
return JsonResponse({"courses": serializer.data}, safe=False)
raise ParseError()
def course_list(request):
if request.method == 'GET':
courses = Course.objects.all()
title = request.GET.get('title', None)
if title is not None:
courses = courses.filter(title__icontains=title)
courses_serializer = CourseSerializer(courses, many=True)
return JsonResponse(courses_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
course_data = JSONParser().parse(request)
course_serializer = CourseSerializer(data=course_data)
if course_serializer.is_valid():
course_serializer.save()
return JsonResponse(course_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(course_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Course.objects.all().delete()
return JsonResponse(
{
'message': '{} Courses were deleted successfully!'.format(
count[0])
},
status=status.HTTP_204_NO_CONTENT)
def get(self, request):
id = request.GET.get("id")
if not id or not check_is_id(id):
return self.error("Invalid parameter, id is required")
try:
contest = Contest.objects.get(id=id, visible=True)
except Contest.DoesNotExist:
return self.error("Contest does not exist")
data = ContestSerializer(contest).data
data["now"] = datetime2str(now())
courses = contest.course_set.all().order_by("-s_year")
data["course"] = CourseSerializer(courses, many=True).data
return self.success(data)
def put(self, request, pk):
course = get_course_or_404(pk)
if course.created_by.id != request.user.id:
return Response({"permission": "denied"},
status=status.HTTP_403_FORBIDDEN)
serializer = CourseSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
if request.user.id != course.created_by.id:
return Response({"permission": "denied"},
status=status.HTTP_403_FORBIDDEN)
validated_data = serializer.data
audit_attrs = get_audit_attrs(course.created_by, request.user)
validated_data.update(audit_attrs)
previous_is_published = course.is_published
course = serializer.update(course, validated_data)
response = serializer.data
if previous_is_published != course.is_published:
#import ipdb; ipdb.set_trace()
response = dict(serializer.data)
if course.is_published:
courseslug = course.publish_and_slugify()
else:
courseslug = None
course.unpublish()
if courseslug is not None:
response['slug'] = courseslug.slug
else:
response['slug'] = None
return Response(response, status.HTTP_200_OK)
def get(self, request):
if request.user.is_authenticated:
user = request.user
users_courses = Course.objects.filter(students=user)
course_serializer = CourseSerializer(users_courses, many=True)
user_serializer = UserProfileSerializer(user)
course_data = course_serializer.data
user_data = user_serializer.data
return Response(data=(course_data, user_data),
status=status.HTTP_200_OK)
else:
return Response({"message": "User is not authenticated"},
status=status.HTTP_400_BAD_REQUEST)
def to_representation(self, value):
if isinstance(value, Student):
serializer = StudentSerializer(value)
elif isinstance(value, Instructor):
serializer = InstructorSerializer(value)
elif isinstance(value, Parent):
serializer = ParentSerializer(value)
elif isinstance(value, Admin):
serializer = AdminSerializer(value)
elif isinstance(value, Course):
serializer = CourseSerializer(value)
elif isinstance(value, Session):
serializer = SessionSerializer(value)
else:
raise Exception("Not recognized model instance!")
return serializer.data
def get(self, request, pk, format=None):
"""
Get course by course_id
"""
course = get_course_or_404(pk)
if not course.is_published and request.user != course.created_by:
return Response(
{
"Have": "a little patience",
"url": "https://youtu.be/273eSvOwpKk"
},
status=status.HTTP_403_FORBIDDEN)
serializer = CourseSerializer(course)
data = serializer.data
return Response(data)
def course_list(request):
"""
获取所有课程信息或新增单条课程信息
:param request:
:return:
"""
if request.method == "GET":
ser = CourseSerializer(instance=Course.objects.all(), many=True)
return Response(data=ser.data, status=status.HTTP_200_OK)
elif request.method == "POST":
ser = CourseSerializer(data=request.data, partial=True)
if ser.is_valid():
ser.save(teacher=request.user)
return Response(data=ser.data, status=status.HTTP_201_CREATED)
return Response(data=ser.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""
增加历史课程
"""
res = {"courses": []}
with transaction.atomic():
for data in JSONParser().parse(request)["courses"]:
if data.get("id", None) is not None:
raise ParseError("不能有主键") # 增加不能有主键
data["offering_course"] = get_object_or_404(OfferingCourse, id=data["offering_course"])
teachers = Teacher.objects.filter(user__username__in=[tea["username"] for tea in data.pop("teachers")])
cms = CM.objects.filter(user__username__in=[cm["username"] for cm in data.pop("cms")])
course = Course.objects.create(**data)
course.teachers.set(teachers)
course.cms.set(cms)
serializer = CourseSerializer(course)
res["courses"].append(serializer.data)
return JsonResponse(res, status=200, safe=False)
def post(self, request, *args, **kwargs):
user = request.user
data = request.data
content = {'text': data['text']}
if "file" in request.FILES:
file = request.FILES['file']
content['file'] = file
serializer = ContentSerializer(data=content)
serializer.is_valid(raise_exception=True)
serializer.save()
course = {
"title": data['title'],
"owner": user.pk,
"description": serializer.instance.pk
}
serializer = CourseSerializer(data=course)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=HTTP_200_OK)
