def put(self, request, primary_key):
"""
update student
:author: lishanZheng
:date: 2020/01/02
"""
student = self.get_object()
if student.id != primary_key:
pass
data = request.data
company_data = data.get("company")
if student.company is None:
company = Company.objects.create(**company_data)
student.company = company
student.save()
else:
company_serializer = CompanySerializer(data=company_data,
partial=True,
instance=student.company)
if company_serializer.is_valid():
company_serializer.save()
student_serializer = StudentSerializer(data=data,
partial=True,
instance=student)
if student_serializer.is_valid():
student_serializer.save()
return result_util.success(student_serializer.data)
def put(self, request, pk, format=None):
student = self.get_object(pk)
serializer = StudentSerializer(student, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = StudentSerializer(data=request.data)
if serializer.is_valid():
student = Student.objects.create_user(
serializer.validated_data['email'],
request.data['password'],
first_name=serializer.validated_data['first_name'],
last_name=serializer.validated_data['last_name'])
return Response({
'student': StudentSerializer(student).data,
'token': student.auth_token.key
})
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_student(request, pk):
if request.method == 'GET':
if id is not None:
res_data = Student.objects.get(id=pk)
serializer = StudentSerializer(res_data)
data = JSONRenderer().render(serializer.data)
return HttpResponse(data, content_type='application/json')
def classifier(student_set):
"""
按首字母分类 后组合
:author: lishanZheng
:date: 2020/01/07
"""
student_list = []
times = len(student_set)
current_letter = ''
for i in range(times):
letter = get_letter(student_set[i].name).upper()
if len(student_list) != 0:
current_letter = student_list[len(student_list) - 1]['letter']
student_serializer_data = StudentSerializer(student_set[i]).data
if current_letter == letter:
section = student_list[len(student_list) - 1]
group = section['group']
group.append(student_serializer_data)
else:
section = get_section()
section['letter'] = letter.upper()
section['group'].append(student_serializer_data)
student_list.append(section)
return student_list
def post(self, request, *args, **kwargs):
posts_serializer = PostSerializer(data=request.data)
students = Student.objects.all()
student_serializer = StudentSerializer(students, many=True)
if posts_serializer.is_valid():
posts_serializer.save()
hog_det.hog('/home/ritodeep/Desktop/form-data/backend' +
posts_serializer.data['image'])
names = utils.predict(
'/home/ritodeep/Desktop/form-data/backend/media/HOG_Test/20-05-2020'
)
# names = mt_embed1.test_im_folder('/home/ritodeep/Desktop/form-data/backend/media/HOG_Test/19-05-2020')
for i in range(len(student_serializer.data)):
if student_serializer.data[i]['name'] in names:
present = student_serializer.data[i]['days_present'] + 1
Student.objects.filter(
name=student_serializer.data[i]['name']).update(
days_present=present)
return JsonResponse(names,
status=status.HTTP_201_CREATED,
safe=False)
else:
print('error', posts_serializer.errors)
return Response(posts_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class SchoolSerializer(serializers.ModelSerializer):
students = StudentSerializer(many=True)
class Meta:
fields = ('id', 'name', 'board', 'students')
model = models.School
def create(self, validated_data):
students = validated_data.pop("students")
print(validated_data)
school = models.School.objects.create(**validated_data)
for student in students:
Student.objects.create(school=school, **student)
return school
def update(self, instance, validated_data, pk=None):
students_data = validated_data.pop('students')
students = (instance.students).all()
students = list(students)
instance.name = validated_data.get('name', instance.name)
instance.board = validated_data.get('board', instance.board)
instance.save()
for student_data in students_data:
student = students.pop(0)
student.name = student_data.get('name', student.name)
student.age = student_data.get('age', student.age)
student.is_adult = student_data.get('is_adult', student.is_adult)
student.save()
return instance
class ParentSerializer(serializers.ModelSerializer):
"""Parent model serializer."""
children = StudentSerializer(required=False, many=True)
class Meta:
model = Parent
fields = '__all__'
def get_all_students(request):
if request.method == 'GET':
# queryset = Student.objects.using('dbname').all()
queryset = Student.objects.all()
serializer = StudentSerializer(queryset, many=True)
data = JSONRenderer().render(serializer.data)
return HttpResponse(data, content_type='application/json')
class UserInfoSerializer(serializers.ModelSerializer):
teacher_user = TeacherSerializer()
student_user = StudentSerializer()
class Meta:
model = User
fields = ('username', 'teacher_user', 'student_user', 'email',
'is_student')
class EnrollmentSerializer(serializers.ModelSerializer):
student = StudentSerializer()
teacher = TeacherSerializer()
lesson = LessonsSerializer()
class Meta:
model = Enrollment
fields = '__all__'
class PostShareSerializer(serializers.ModelSerializer):
post = PostSerializer()
student = StudentSerializer()
datetime = serializers.DateTimeField()
class Meta:
model = models.PostShare
fields = "__all__"
def create(self, validated_data):
return models.PostShare.objects.create(**validated_data)
def get_registered_participants(event):
from student.models import Registration
registrations = Registration.objects.filter(event=event)
participants = []
for registration in registrations:
participants.append(registration.student)
from student.serializers import StudentSerializer
data = StudentSerializer(participants, many=True).data
return data
def get(self, request):
queryset = Student.objects.all()
test_token = self.request.query_params.get('codeSmartick', None)
student = queryset.filter(log_code=test_token).first()
if student is not None:
serializer = StudentSerializer(student)
return Response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
class AttendanceSerializer(serializers.ModelSerializer):
class_level = ClasslevelSerializer()
student = StudentSerializer()
subject = SubjectSerializer()
class Meta:
model = Attendance
fields = '__all__'
class AttendanceSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
class_level = ClasslevelSerializer()
student = StudentSerializer()
subject = SubjectSerializer()
class Meta:
model = Attendance
fields = '__all__'
extra_fields = ['url']
class AdmissionSerializer(serializers.HyperlinkedModelSerializer):
id = serializers.ReadOnlyField()
academic_year = AcademicYearSerializer()
student = StudentSerializer()
class_level = ClassLevelSerializer()
class Meta:
model = Admission
fields = '__all__'
extra_fields = ['url']
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 get(self, request, primary_key):
"""
get student by id
:author: lishanZheng
:date: 2020/01/11
"""
student = self.get_object()
student.id = primary_key
student = StudentSerializer(student).data
return result_util.success(student)
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
user = serializer.validated_data['user']
token = Token.objects.get_or_create(user=user)
return Response({
'student': StudentSerializer(user).data,
'token': token[0].key,
})
def get_students(self, obj):
ordered_queryset = Student.objects.order_by("name").filter(school=obj)
student_name = self.context['request'].query_params.get('name', None)
if student_name:
ordered_queryset = ordered_queryset.filter(name=student_name)
student_age = self.context['request'].query_params.get('age', None)
if student_age:
ordered_queryset = ordered_queryset.filter(age=student_age)
return StudentSerializer(ordered_queryset,
many=True,
context=self.context).data
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data
user_profile_object = UserProfile.objects.get(pk=user.id)
# Get Roles
es_helper = ElasticModelViewSet()
# Get User Profile and add ES data
user_profile = UserProfileSerializer(user_profile_object).data
es_helper.add_es_data([
user_profile,
], UserProfileDocument)
# Get Educator and add ES data (if exists)
try:
educator = EducatorSerializer(user_profile_object.educator).data
es_helper.add_es_data([
educator,
], EducatorDocument)
except ObjectDoesNotExist:
educator = None
# Get Student and add ES data (if exists)
try:
student = StudentSerializer(user_profile_object.student).data
es_helper.add_es_data([
student,
], StudentDocument)
except ObjectDoesNotExist:
student = None
# Get Parent and add ES data (if exists)
try:
parent = ParentSerializer(user_profile_object.parent).data
es_helper.add_es_data([
parent,
], ParentDocument)
except ObjectDoesNotExist:
parent = None
return Response(
{
'user_profile': user_profile,
'educator': educator,
'student': student,
'parent': parent,
"token": AuthToken.objects.create(user)[1]
}, 200)
def student_list(request):
if request.method == 'GET':
student = Student.objects.all()
serializer = StudentSerializer(student, many=True)
return Response(serializer.data)
elif request.method == 'POST':
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)
class PostSerializer(serializers.ModelSerializer):
student = StudentSerializer()
description = serializers.TextField()
datetime = serializers.DateTimeField()
class Meta:
model = models.Post
fields = "__all__"
def create(self, validated_data):
return models.Post.objects.create(**validated_data)
def update(self, instance, validated_data):
instance.student = validated_data.get('student', instance.student)
instance.description = validated_data.get('description', instance.description)
instance.datetime = validated_data.get('datetime', instance.datetime)
instance.save()
return instance
def get_students_class(request, class_id):
try:
queryset = Student.objects.filter(class_data=class_id)
serialized = StudentSerializer(queryset, many=True)
response = success.APIResponse(200, serialized.data).respond()
except Student.DoesNotExist as not_found_error:
error_message = "Student with given class {} is Not available".format(
class_id)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = error.APIErrorResponse(400, err).respond()
finally:
return (Response(response))
def student_detail(request, pk):
try:
student = Student.objects.get(pk=pk)
except Student.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = StudentSerializer(student)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = StudentSerializer(student, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
serializer = StudentSerializer(student, data=request.data)
student.delete()
print("berhasil")
return Response(status=status.HTTP_204_NO_CONTENT)
class PostReactSerializer(serializers.ModelSerializer):
post = PostSerializer()
student = StudentSerializer()
type = models.CharField()
datetime = serializers.DateTimeField()
class Meta:
model = models.PostReact
fields = "__all__"
def create(self, validated_data):
return models.PostReact.objects.create(**validated_data)
def update(self, instance, validated_data):
instance.post = validated_data.get('post', instance.post)
instance.student = validated_data.get('student', instance.student)
instance.type = validated_data.get('type', instance.type)
instance.datetime = validated_data.get('datetime', instance.datetime)
instance.save()
return instance
class ActivityStudentSerializer(ModelSerializer):
"""
activity student serializer
:author: gexuewen
:date: 2020/01/02
"""
activity = ActivitySerializer(many=False, read_only=True)
student = StudentSerializer(many=False, read_only=True)
class Meta:
model = ActivityStudent
fields = '__all__'
def create(self, validated_data):
return ActivityStudent.objects.create(
activity=self.context["activity"],
student=self.context['student'],
**validated_data)
def get_user_profiles(self, request):
# Get User Profile and add ES data
user_profile = UserProfileSerializer(request.user.user_profile).data
self.add_es_data([
user_profile,
], UserProfileDocument)
# Get Educator and add ES data (if exists)
try:
educator = EducatorSerializer(
request.user.user_profile.educator).data
self.add_es_data([
educator,
], EducatorDocument)
except ObjectDoesNotExist:
educator = None
# Get Student and add ES data (if exists)
try:
student = StudentSerializer(request.user.user_profile.student).data
self.add_es_data([
student,
], StudentDocument)
except ObjectDoesNotExist:
student = None
# Get Parent and add ES data (if exists)
try:
parent = ParentSerializer(request.user.user_profile.parent).data
self.add_es_data([
parent,
], ParentDocument)
except ObjectDoesNotExist:
parent = None
result = {
'user_profile': user_profile,
'educator': educator,
'student': student,
'parent': parent
}
return Response(result, 200)
def post(self, request):
""" 新增某学号数据 """
request_data = request.body.decode('utf-8')
python_dict = json.loads(request_data, encoding='utf-8')
# 反序列化
serializer = StudentSerializer(data=python_dict)
try:
# 反序列化验证
serializer.is_valid(raise_exception=True)
except Exception as e:
return JsonResponse({"msg": "添加失败", "error": serializer.errors}, safe=False)
# 序列化创建数据，保存
serializer.save()
return JsonResponse({"code": "201", "msg": "添加成功", "data": serializer.data}, safe=False)
def post(self, request, format=None):
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)
