def post(self, request, *args, **kwargs):
data = request.data
serializer = StudentSerializer(data=data, many=True)
if serializer.is_valid():
try:
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
except IntegrityError:
return Response("Data already exists", status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs):
json_data = request.body
stream = io.BytesIO(json_data)
pythondata = JSONParser().parse(stream)
id = pythondata.get('id')
stu = Student.objects.get(id=id)
serializer = StudentSerializer(stu, data=pythondata, partial=True)
if serializer.is_valid():
serializer.save()
res = {"msg": "Partial Data Created"}
json_data = JSONRenderer().render(res)
return HttpResponse(json_data, content_type="application/json")
json_data = JSONRenderer().render(serializer.errors)
return HttpResponse(json_data, content_type="application/json")
def post(self, request):
serializer = StudentSerializer(data=request.data)
if serializer.is_valid():
if request.user.is_student():
if request.user.student.id == serializer.validated_data['id']:
serializer.save()
return Response(serializer.data)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def studentApi(request, id=0):
if request.method == 'GET':
students = Students.objects.all()
student_serializer = StudentSerializer(students, many=True)
return JsonResponse(student_serializer.data, safe=False)
elif request.method == 'POST':
student_data = JSONParser().parse(request)
student_serializer = StudentSerializer(data=student_data)
if student_serializer.is_valid():
student_serializer.save()
return JsonResponse("Added Successfully!", safe=False)
return JsonResponse("Failed to add", safe=False)
elif request.method == 'PUT':
student_data = JSONParser().parse(request)
student = Students.objects.get(StudentId=student_data['StudentId'])
student_serializer = StudentSerializer(student, data=student_data)
if student_serializer.is_valid():
student_serializer.save()
return JsonResponse("Updated Successfully!", safe=False)
return JsonResponse("Failed to update", safe=False)
elif request.method == 'DELETE':
student = Students.objects.get(StudentId=id)
student.delete()
return JsonResponse("Deleted Successfully!", safe=False)
def list(self, request, *args, **kwargs):
keyword = request.GET.get('keyword')
sex = request.GET.get('sex')
# if keyword is not None:
if keyword in ('', None) and sex not in ('', None):
queryset = Student.objects.filter(sex=sex)
elif keyword not in ('', None) and sex in ('', None):
queryset = Student.objects.filter(name__contains=keyword)
elif keyword not in ('', None) and sex not in ('', None):
# 执行filter() 方法
queryset = Student.objects.filter(name__contains=keyword, sex=sex)
else:
# 如果参数为空， 执行all()方法
queryset = Student.objects.all()
serializer = StudentSerializer(queryset, many=True)
return Response(serializer.data)
class TeacherSerializer(serializers.HyperlinkedModelSerializer):
user = UserSerializer(read_only=True)
students = StudentSerializer(read_only=True, many=True)
class Meta:
model = Teacher
fields = ('id', 'connection_key', 's3_user_key', 'url', 'bio',
'street', 'city', 'region', 'country', 'zip_code', 'user',
'students')
depth = 1
def create(self, validated_data):
teacher = Teacher.objects.create(**validated_data)
teacher.generate_key()
teacher.save()
return teacher
def get(self, request, *args, **kwargs):
stu_id = kwargs.get('pk')
if stu_id:
stu_obj = Student.objects.get(pk=stu_id)
many = False
else:
stu_obj = Student.objects.all()
many = True
stu_ser = StudentSerializer(stu_obj, many=many)
return Response({
'status': 200,
'messages': '查询成功',
'result': stu_ser.data
})
def listStudentCurrentAssing(self, request, *args, **kwargs):
data = request.data
try:
with transaction.atomic():
print("DATA listStudentCurrentAssing:", data)
_id = data.get("id")
if _id is not None:
assign_student = AssignmentStudent.objects.filter(
assignment=_id, activo=True)
student_id_list = [
element.student_id for element in assign_student
]
_students = Student.objects.filter(id__in=student_id_list,
activo=True)
student_serializer = StudentSerializer(_students,
many=True)
return Response({"results": student_serializer.data},
status=status.HTTP_200_OK)
else:
return Response(
{
"detail":
"You didnt send all the necessary data or empty array"
},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
"detail":
"Somenthing was wrong, its not possible to update assignment to student"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
return Response({"detail": "User not found"},
status=status.HTTP_404_NOT_FOUND)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
def test_student_data_stored(self):
data = [{
"matricNo": "1234567",
"givenNames": "Philip J",
"surname": "Fry",
"academicPlan": "F100-2208",
"gradYear": "19-20",
"finalAward1": 0.0,
"finalAward2": 0.00,
"finalAward3": 0.000
}, {
"matricNo": "7654321",
"givenNames": "Hermes",
"surname": "Conrad",
"academicPlan": "F100-2208",
"gradYear": "19-20",
"finalAward1": 0.0,
"finalAward2": 0.00,
"finalAward3": 0.000
}]
serializer = StudentSerializer(data=data, many=True)
if serializer.is_valid():
serializer.save()
student1 = Student.objects.filter(
matricNo="1234567",
givenNames="Philip J",
surname="Fry",
academicPlan="F100-2208",
gradYear=GraduationYear.objects.get(gradYear="19-20"),
finalAward1=0.0,
finalAward2=0.00,
finalAward3=0.000).exists()
student2 = Student.objects.filter(
matricNo="7654321",
givenNames="Hermes",
surname="Conrad",
academicPlan="F100-2208",
gradYear=GraduationYear.objects.get(gradYear="19-20"),
finalAward1=0.0,
finalAward2=0.00,
finalAward3=0.000).exists()
self.assertTrue(student1)
self.assertTrue(student2)
def post(self, request):
"""
Enroll in a labgroup.
"""
# ensure all parameters are present in the request data
for param in ('wwuid', 'labgroup', 'enroll_key'):
if param not in request.data.keys():
return Response(status=status.HTTP_400_BAD_REQUEST)
# load the labgroup from the database
try:
labgroup = LabGroup.objects.get(id=request.data['labgroup'])
except LabGroup.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
# check enroll key
if request.data['enroll_key'] != labgroup.enroll_key:
return Response(status=status.HTTP_403_FORBIDDEN)
# delete student if it exists
try:
student = Student.objects.get(user=request.user)
student.delete()
except Student.DoesNotExist:
pass
# validate student data in request
student_data = {
'user': request.user.id,
'labgroup': labgroup.id,
'wwuid': request.data['wwuid'],
}
serializer = StudentSerializer(data=student_data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# create the student
student = Student(user=request.user,
labgroup=labgroup,
wwuid=request.data['wwuid'])
student.save()
# add new student to the student group
group = permissions.get_or_create_student_permissions()
group.user_set.add(request.user)
# return successful response
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, *args, **kwargs):
stu_data = request.data
if not isinstance(stu_data, dict) or stu_data == {}:
return Response({'status': 500, 'msg': '数据有误'})
stu_des = StudentDeSerializer(data=stu_data)
if stu_des.is_valid():
new_stu = stu_des.save()
return Response({
'status': 200,
'msg': '添加成功',
'result': StudentSerializer(new_stu).data
})
else:
return Response({
'status': 500,
'msg': '添加失败',
'detail': stu_des.errors
})
def get(self, request, pk):
print(pk)
snippet = Student.objects.filter(id=pk)
serializer = StudentSerializer(snippet, many=True)
return Response(serializer.data)
def get(self, request):
snippet = Student.objects.filter(user=request.user)
serializer = StudentSerializer(snippet, many=True)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
data = request.data
try:
with transaction.atomic():
avatar = data.get("avatar")
data = json.loads(data.get("data"))
_profile = data.get('profile')
_user = data.get('user')
_role = data.get('role')
_student = data.get('student')
print('CREAR ESTUDIANTE:', data)
print('CREAR ESTUDIANTE AVATAR:', avatar)
try:
User.objects.get(username=_user.get('username'))
return Response(
{
"detail":
"El nombre de usuario no está disponible, por favor escoge otro"
},
status=status.HTTP_406_NOT_ACCEPTABLE)
except User.DoesNotExist:
pass
try:
User.objects.get(email=_user.get('email'))
return Response(
{
"detail":
"El correo electronico no está disponible, por favor escoge otro"
},
status=status.HTTP_406_NOT_ACCEPTABLE)
except User.DoesNotExist:
pass
if _profile is not None and _user is not None and _role is not None and _student is not None:
try:
User.objects.get(username=_user.get('username'))
return Response(
{
"detail":
"the chosen username in not available, please pick another"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
pass
user_c = User.objects.create(
username=_user.get('username'),
first_name=_user.get('first_name'),
last_name=_user.get('last_name'),
email=_user.get("email"))
user_c.set_password(_user.get('password'))
role_c = Role.objects.get(id=_role)
profile_c, created = Profile.objects.get_or_create(
user=user_c, role=role_c)
profile_c.phone = _profile.get("phone", profile_c.phone)
profile_c.address = _profile.get("address",
profile_c.address)
profile_c.gender = _profile.get("gender", profile_c.gender)
if avatar is not None:
profile_c.avatar = File(avatar)
student_c = Student.objects.create(
card_id=_student.get('card_id'),
contact_name=_student.get('contact_name'),
contact_phone=_student.get('contact_phone'),
contact_address=_student.get('contact_address'),
profile=profile_c,
)
user_c.save()
profile_c.save()
student_c.save()
my_serializer = StudentSerializer(student_c)
return Response({"student": my_serializer.data},
status=status.HTTP_200_OK)
else:
return Response(
{"detail": "You didnt send all the necessary data"},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
"detail":
"Somenthing was wrong, its no possible to create student"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
return Response({"detail": "User not found"},
status=status.HTTP_404_NOT_FOUND)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
def my_qualifications(self, request):
_student = request.user.profile.student
try:
with transaction.atomic():
myStudent = Student.objects.filter(
id=_student.id,
activo=True).prefetch_related('assignstudent_student')
if myStudent[0] is not None:
queryStudent = StudentSerializer(_student)
dataStudent = queryStudent.data
qualifications = {'student': dataStudent, 'allAssign': []}
for a_s in myStudent[0].assignstudent_student.filter(
activo=True):
assign = a_s.assignment
homeworks = assign.homework_assignment.filter(
activo=True)
oneAssignment = {
'assignment': {
"id":
assign.id,
'name':
assign.course.name + ", " + assign.grade.name +
", " + assign.section.name
}
}
answers = []
total = 0
for hw in homeworks:
homeworkStudent = hw.homeworkstudent_homework.filter(
activo=True, student=dataStudent.get('id'))
dataHomework = {
"id": hw.id,
"title": hw.title,
"description": hw.description,
"myvalue": hw.myvalue
}
for h_s in homeworkStudent:
if (h_s.student == _student):
data = {
"homework": dataHomework,
"points": h_s.points,
"submitted": True
}
answers.append(data)
if h_s.points is not None:
total += float(h_s.points)
else:
total += 0
else:
data = {
"homework": dataHomework,
"points": None,
"submitted": False
}
answers.append(data)
total += 0
oneAssignment["answers"] = answers
oneAssignment["total"] = total
qualifications.get("allAssign").append(oneAssignment)
print("La DATONGA BROU:", qualifications)
return Response({"student": qualifications},
status=status.HTTP_200_OK)
else:
return Response(
{"detail": "You didnt send all the necessary data"},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
"detail":
"Somenthing was wrong, its no possible to create student"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
return Response({"detail": "User not found"},
status=status.HTTP_404_NOT_FOUND)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
students = Student.objects.all()
serializer = StudentSerializer(students, many=True)
return Response(serializer.data)
def post(self, request):
lserializer = StudentSerializer(data=request.DATA.get('student'))
if lserializer.is_valid():
lserializer.save()
return Response(lserializer.data, status=status.HTTP_201_CREATED)
return Response(lserializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk):
teacher = Teacher.objects.get(pk=pk)
return Response(StudentSerializer(teacher.student_set, many=True).data)
def create(self, request, *args, **kwargs):
serializer = StudentSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def viewStudent(request,pk):
student = Student_model.objects.get(id=pk)
serializer = StudentSerializer(student, many=False)
return Response(serializer.data)
def showAllStudents(request):
Students = Student_model.objects.all()
serializer = StudentSerializer(Students, many=True)
return Response(serializer.data)
def get(self, request, pk, format=None):
student = self.get_object(pk)
serializer = StudentSerializer(student)
return Response(serializer.data)
def create(self, request):
serializer = StudentSerializer(data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
serializer.save(user=request.user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
class EnrollStatusSerializer(serializers.Serializer):
"""
The serializer for enroll status.
"""
user = UserSerializer(read_only=True)
student = StudentSerializer(read_only=True)
def update(self, request, pk):
data = request.data
try:
with transaction.atomic():
avatar = data.get("avatar")
data = json.loads(data.get("data"))
_profile = data.get('profile')
_user = data.get('user')
_role = data.get('role')
_student = data.get('student')
print('CREAR ESTUDIANTE:', data)
print('CREAR ESTUDIANTE AVATAR:', avatar)
if _profile is not None and _user is not None and _role is not None and _student is not None:
student_actual = Student.objects.get(id=pk)
profile_actual = Profile.objects.get(
id=student_actual.profile_id)
user_actual = User.objects.get(id=profile_actual.user_id)
if user_actual.username != _user.get('username'):
try:
User.objects.get(username=_user.get('username'))
return Response(
{
"detail":
"El nombre de usuario no está disponible, por favor escoge otro"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
pass
if user_actual.email != _user.get('email'):
try:
User.objects.get(email=_user.get('email'))
return Response(
{
"detail":
"El correo electronico no está disponible, por favor escoge otro"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
pass
user_actual.username = _user.get('username',
user_actual.username)
user_actual.first_name = _user.get('first_name',
user_actual.first_name)
user_actual.last_name = _user.get('last_name',
user_actual.last_name)
user_actual.email = _user.get('email', user_actual.email)
if _user.get("password"
) is not None and _user.get("password") != "":
user_actual.set_password(_user.get('password'))
profile_actual.phone = _profile.get(
"phone", profile_actual.phone)
profile_actual.address = _profile.get(
"address", profile_actual.address)
profile_actual.gender = _profile.get(
"gender", profile_actual.gender)
if avatar is not None:
profile_actual.avatar = File(avatar)
student_actual.card_id = _student.get('card_id'),
student_actual.contact_name = _student.get('contact_name')
student_actual.contact_phone = _student.get(
'contact_phone')
student_actual.contact_address = _student.get(
'contact_address')
user_actual.save()
profile_actual.save()
student_actual.save()
my_serializer = StudentSerializer(student_actual)
return Response({"student": my_serializer.data},
status=status.HTTP_200_OK)
else:
return Response(
{"detail": "You didnt send all the necessary data"},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
"detail":
"Somenthing was wrong, its no possible to create student"
},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
return Response({"detail": "User not found"},
status=status.HTTP_404_NOT_FOUND)
except KeyError as e:
return Response(
{"detail": "{} is a required field".format(str(e))},
status=status.HTTP_400_BAD_REQUEST)
