def post(self, request, format=None):
serializer = StudentSerializer(data=request.data)
print('serializer', serializer)
if serializer.is_valid():
serializer.save()
return Response({'msg': 'Data Inserted'},
status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def get(self, request, pk=None, format=None):
get_id = pk
if get_id is not None:
students = Student.objects.get(id=get_id)
serializer = StudentSerializer(students)
return Response(serializer.data)
else:
students = Student.objects.all()
serializer = StudentSerializer(students, many=True)
return Response(serializer.data)
class ProjectProposalSerializer(serializers.ModelSerializer):
member1 = StudentSerializer(many=False, read_only=True)
member2 = StudentSerializer(many=False, read_only=True)
member3 = StudentSerializer(many=False, read_only=True)
member4 = StudentSerializer(many=False, read_only=True)
mentor = TeacherSerializer(many=False, read_only=True)
class Meta:
model = Project
exclude = ('associated_files', 'proposal')
def put(self, request, pk, format=None):
get_id = pk
student = Student.objects.get(id=get_id)
serializer = StudentSerializer(student, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({'msg': 'Complete Data Updated.'},
status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def patch(self, request, pk, format=None):
get_id = pk
student = Student.objects.get(id=get_id)
serializer = StudentSerializer(student,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return Response({'msg': 'Partial Data Updated'})
return Response(serializer.errors)
def setUp(self):
self.date = pytz.timezone("America/New_York").localize(
datetime.datetime(2019, 1, 1))
self.user = get_user_model().objects.create_user(
pennid=1,
username="******",
password="******",
first_name="First",
last_name="Last",
email="*****@*****.**",
)
self.active_major_1 = Major.objects.create(name="Test Active Major",
is_active=True)
self.active_major_2 = Major.objects.create(name="Test Active Major 2",
degree_type="PHD",
is_active=True)
self.school = School.objects.create(name="Test School")
self.user.student.major.add(
Major.objects.get(name="Test Active Major"))
self.user.student.major.add(
Major.objects.get(name="Test Active Major 2"))
self.user.student.school.add(School.objects.get(name="Test School"))
self.serializer = StudentSerializer(self.user.student)
def student_create(request):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
major = Major.objects.get(name=body['major'])
level = Level.objects.get(level=body['level'])
modeOfEntry = ModeOfEntry.objects.get(name=body['modeOfEntry'])
dateBirth = body['dateBirth']
user = User()
user.username = body['username']
user.password = dateBirth
user.first_name = body['first_name']
user.last_name = body['last_name']
user.email = body['email']
user.type = '7'
user.sex = body['sex']
user.save()
student = Student()
student.user = user
student.major = major
student.level = level
student.modeOfEntry = modeOfEntry
student.status = '1'
student.dateBirth = dateBirth
student.save()
serial = StudentSerializer(student)
return JsonResponse(serial.data, safe=False, status=200)
def setUp(self):
self.user = get_user_model().objects.create_user(
pennid=1,
username="******",
password="******",
first_name="First",
last_name="Last",
email="*****@*****.**",
)
Major.objects.create(name="Test Active Major",
is_active=True,
degree_type="BACHELORS")
Major.objects.create(name="Test Active Major 2",
degree_type="PHD",
is_active=True)
Major.objects.create(name="Test Active Major 3",
degree_type="PROFESSIONAL",
is_active=True)
School.objects.create(name="Test School")
School.objects.create(name="Test School 2")
self.user.student.major.add(
Major.objects.get(name="Test Active Major"))
self.user.student.major.add(
Major.objects.get(name="Test Active Major 2"))
self.user.student.school.add(School.objects.get(name="Test School"))
self.user.student.graduation_year = 2024
self.serializer = StudentSerializer(self.user.student)
self.client = APIClient()
self.serializer = UserSerializer(self.user)
class EnterpriseSerializers(serializers.ModelSerializer):
students = StudentSerializer(many=True, read_only=True)
projects = ProjSerializer(many=True, read_only=True)
framers = FramerSerializer(many=True, read_only=True)
class Meta:
model = Enterprise
fields = '__all__'
class ApplicationSerializer(serializers.ModelSerializer):
project = ProjectSerializer(read_only=True)
student = StudentSerializer(read_only=True)
project_id = serializers.PrimaryKeyRelatedField(queryset = Project.objects.all(), source='project', write_only=True)
student_id = serializers.PrimaryKeyRelatedField(queryset = Student.objects.all(), source='student', write_only=True)
class Meta:
model = Application
fields = '__all__'
def students(self, request, pk=None):
instance = self.get_object()
params = request.query_params
queryset = models.User.objects.filter(
profile__student_info__section_id=instance.id,
is_active=True).select_related('profile__student_info')
if 'download' in params and params['download'] == 'true':
return self.get_downloadable_link(queryset)
serializer = StudentSerializer(queryset, many=True)
return Response(status=status.HTTP_200_OK, data=serializer.data)
def get(self, request, pk, format=None):
studentClass = self.get_object(pk=pk)
studentsInClass = StudentProfile.objects.filter(
student_class=studentClass).all()
classSerializer = StudentsClassDetailSerializer(studentClass)
studentSerializer = StudentSerializer(studentsInClass, many=True)
return Response({
"Main info": classSerializer.data,
"Students": studentSerializer.data
})
class StudentAssessmentSerializer(serializers.ModelSerializer):
student = StudentSerializer(read_only=True)
class Meta:
model = models.StudentAssessment
fields = (
'id',
'student',
'student_id',
'assessment',
'obtained_marks',
'comments',
)
def setUp(self):
self.date = pytz.timezone("America/New_York").localize(
datetime.datetime(2019, 1, 1))
self.user = get_user_model().objects.create_user(
pennid=1,
username="******",
password="******",
first_name="First",
last_name="Last",
email="*****@*****.**",
)
Student.objects.create(user=self.user)
self.user.student.name = "Student"
self.user.student.major = "Major"
self.user.student.school = "School"
self.serializer = StudentSerializer(self.user.student)
def students(self, request, pk=None):
course = Course.objects.get(pk=pk)
students_ = course.student.all()
return Response(
{"students": StudentSerializer(students_, many=True).data})
def student(request):
if request.method == 'GET':
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id', None)
if id is not None:
stu = Student.objects.get(id=id)
serializr = StudentSerializer(stu)
json_data = JSONRenderer().render(serializr.data)
return HttpResponse(json_data, content_type='application/json')
else:
stu = Student.objects.all()
serializr = StudentSerializer(stu, many=True)
json_data = JSONRenderer().render(serializr.data)
return HttpResponse(json_data, content_type='application/json')
if request.method == 'POST':
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
serializr = StudentSerializer(data=python_data)
if serializr.is_valid():
serializr.save()
response = {'msg': 'Data inserted.'}
json_data = JSONRenderer().render(response)
return HttpResponse(json_data, content_type='application/json')
else:
json_data = JSONRenderer().render(serializr.errors)
return HttpResponse(json_data, content_type='application/json')
if request.method == 'PUT':
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
stu = Student.objects.get(id=id)
serializr = StudentSerializer(stu, data=python_data, partial=True)
if serializr.is_valid():
serializr.save()
response = {'msg': 'Data updated.'}
json_data = JSONRenderer().render(response)
return HttpResponse(json_data, content_type='application/json')
# else:
json_data = JSONRenderer().render(serializr.errors)
return HttpResponse(json_data, content_type='application/json')
if request.method == 'DELETE':
json_data = request.body
stream = io.BytesIO(json_data)
python_data = JSONParser().parse(stream)
id = python_data.get('id')
stu = Student.objects.get(id=id)
stu.delete()
response = {'msg': 'Data deleted.'}
# json_data = JSONRenderer().render(response)
# return HttpResponse(json_data, content_type='application/json')
return JsonResponse(response, safe=False)
def get_student(self, obj):
return StudentSerializer(Student.objects.get(pk=obj.student.id)).data
class StudentAttendanceItemSerializer(serializers.ModelSerializer):
student = StudentSerializer(read_only=True)
class Meta:
model = models.StudentAttendanceItem
fields = ('__all__')
def get_student(self, obj):
student = Student.objects.get(pk=obj.student)
student_s = StudentSerializer(student).data
return student_s
