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)