class CasEleveSerializer(serializers.ModelSerializer):
send_to_teachers = serializers.BooleanField(write_only=True,
required=False)
matricule = StudentSerializer(read_only=True)
matricule_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='matricule',
required=False,
allow_null=True)
info = InfoEleveSerializer(read_only=True)
info_id = serializers.PrimaryKeyRelatedField(
queryset=InfoEleve.objects.all(),
source='info',
required=False,
allow_null=True)
sanction_decision = SanctionDecisionDisciplinaireSerializer(read_only=True)
sanction_decision_id = serializers.PrimaryKeyRelatedField(
queryset=SanctionDecisionDisciplinaire.objects.all(),
source='sanction_decision',
required=False,
allow_null=True)
class Meta:
model = CasEleve
fields = '__all__'
read_only_fields = (
'user',
'datetime_encodage',
)
class StudentLatenessTeacherSerializer(serializers.ModelSerializer):
# In order to write with the id and read the entire object, it uses two fields: field + field_id.
student = StudentSerializer(read_only=True)
student_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='student',
required=False,
allow_null=True)
lesson = LessonSerializer(read_only=True)
lesson_id = serializers.PrimaryKeyRelatedField(
queryset=LessonModel.objects.all(),
source='lesson',
required=False,
allow_null=True)
period = PeriodSerializer(read_only=True)
period_id = serializers.PrimaryKeyRelatedField(
queryset=PeriodModel.objects.all(),
source='period',
required=False,
allow_null=True)
class Meta:
model = StudentLatenessTeacherModel
exclude = (
'datetime_creation',
'datetime_update',
)
read_only_fields = ('user', )
class AppelSerializer(serializers.ModelSerializer):
# In order to write with the id and read the entire object, it uses two fields field + field_id.
matricule = StudentSerializer(read_only=True)
matricule_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='matricule',
required=False,
allow_null=True)
responsible = ResponsibleSerializer(read_only=True)
responsible_pk = serializers.PrimaryKeyRelatedField(
queryset=ResponsibleModel.objects.all(),
source='responsible',
required=False,
allow_null=True)
motive = MotiveSerializer(read_only=True)
motive_id = serializers.PrimaryKeyRelatedField(
queryset=MotiveModel.objects.all(), source='motive', write_only=True)
object = ObjectSerializer(read_only=True)
object_id = serializers.PrimaryKeyRelatedField(
queryset=ObjectModel.objects.all(), source='object', write_only=True)
class Meta:
model = Appel
exclude = (
'datetime_encodage',
'motif',
'objet',
)
read_only_fields = ('user', )
def serialize_people(person):
if not person:
return {}
if type(person) == StudentModel:
return StudentSerializer(person).data
elif type(person) == ResponsibleModel:
return ResponsibleSerializer(person).data
class CasEleveSerializer(serializers.ModelSerializer):
send_to_teachers = serializers.BooleanField(write_only=True,
required=False)
matricule = StudentSerializer(read_only=True)
matricule_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='matricule',
required=False,
allow_null=True)
info = InfoEleveSerializer(read_only=True)
info_id = serializers.PrimaryKeyRelatedField(
queryset=InfoEleve.objects.all(),
source='info',
required=False,
allow_null=True)
sanction_decision = SanctionDecisionDisciplinaireSerializer(read_only=True)
sanction_decision_id = serializers.PrimaryKeyRelatedField(
queryset=SanctionDecisionDisciplinaire.objects.all(),
source='sanction_decision',
required=False,
allow_null=True)
def validate_sanction_decision_id(self, value):
# If submit sanction is not enable, ignore validation.
if not views.get_settings().enable_submit_sanctions:
return value
if not self.context['request'].user.has_perm(
'dossier_eleve.ask_sanction'):
raise serializers.ValidationError(
"Vous n'avez pas les droits nécessaire pour ajouter/modifier une sanction"
)
return value
def validate_datetime_sanction(self, value):
if not self.context['request'].user.has_perm(
'dossier_eleve.set_sanction') and value:
raise serializers.ValidationError(
"Vous n'avez pas les droits nécessaire pour ajouter/modifier la date d'une sanction"
)
return value
def validate_sanction_faite(self, value):
if not self.context['request'].user.has_perm(
'dossier_eleve.set_sanction') and value:
raise serializers.ValidationError(
"Vous n'avez pas les droits nécessaire pour mettre une sanction comme faite"
)
return value
class Meta:
model = CasEleve
fields = '__all__'
read_only_fields = (
'user',
'datetime_encodage',
)
def get(self, request, format=None):
classe_id = request.GET.get('classe', None)
if not classe_id or not classe_id.isdigit:
return Response([])
students = StudentModel.objects.filter(classe__id=classe_id).order_by(
'last_name', 'first_name')
serializer = StudentSerializer(students, many=True)
return Response(serializer.data)
class LatenessSerializer(serializers.ModelSerializer):
# In order to write with the id and read the entire object, it uses two fields field + field_id.
student = StudentSerializer(read_only=True)
student_id = serializers.PrimaryKeyRelatedField(queryset=StudentModel.objects.all(),
source='student', required=False, allow_null=True)
class Meta:
model = LatenessModel
fields = ('id', 'student', 'student_id', 'datetime_creation', 'sanction_id',
'lateness_count', 'justified', 'has_sanction')
class PassageSerializer(serializers.ModelSerializer):
matricule = StudentSerializer(read_only=True)
matricule_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='matricule',
required=False,
allow_null=True)
class Meta:
model = Passage
fields = '__all__'
def find(request):
try:
# [Json to Dict]
params = json.loads(request.body)
first_name = params['first_name']
student = Student.objects.get(first_name=first_name)
# # [Object to Json]
serial = StudentSerializer(instance=student)
return Res(serial.data)
except Exception as e:
return errorView.my_error(e)
def create(self, request, *args, **kwargs):
serializer = SchoolStudentCreateSerializer(data=request.data, many=False)
school = SchoolService.get(pk=kwargs['pk'])
student = StudentService.create(
school=school,
first_name=serializer.validated_data.get('first_name'),
last_name=serializer.validated_data.get('last_name')
)
return Response(StudentSerializer(student).data, status=status.HTTP_200_OK)
class PassageSerializer(serializers.ModelSerializer):
matricule = StudentSerializer(read_only=True)
matricule_id = serializers.PrimaryKeyRelatedField(queryset=StudentModel.objects.all(),
source='matricule', required=False,
allow_null=True)
def validate(self, data):
if data['datetime_sortie'] and not data['remarques_sortie']:
raise serializers.ValidationError("Une remarque de sortie doit être indiquée")
return data
class Meta:
model = Passage
fields = '__all__'
class PIASerializer(serializers.ModelSerializer):
student = StudentSerializer(read_only=True)
student_id = serializers.PrimaryKeyRelatedField(queryset=StudentModel.objects.all(),
source='student', required=False,
allow_null=True)
referent = serializers.SlugRelatedField(many=True, slug_field="matricule",
queryset=ResponsibleModel.objects.all())
sponsor = serializers.SlugRelatedField(many=True, slug_field="matricule",
queryset=ResponsibleModel.objects.all())
class Meta:
model = models.PIAModel
fields = '__all__'
class GroupSerializer(serializers.ModelSerializer):
students = StudentSerializer(read_only=True, many=True)
students_id = serializers.PrimaryKeyRelatedField(
queryset=StudentModel.objects.all(),
source='students',
required=False,
allow_null=True,
many=True)
students_display = serializers.SerializerMethodField()
class Meta:
model = models.GroupModel
fields = "__all__"
def get_students_display(self, obj):
return [s.fullname_classe for s in obj.students.all()]
def put(self, request, pk):
serializer = StudentUpdateSerializer(data=request.data, many=False)
student = StudentService.get(pk=pk)
if not serializer.is_valid():
return NotAcceptableExceptionResponse(data={'message': INVALID_INPUT, 'errors': serializer.errors})
school = None
if serializer.validated_data.get('school_id'):
school = SchoolService.get(id=serializer.validated_data.get('school_id'))
student = StudentService.update(
student=student,
school=school,
first_name=serializer.validated_data.get('first_name'),
last_name=serializer.validated_data.get('last_name')
)
return Response(StudentSerializer(student).data, status=status.HTTP_200_OK)
class StudentAbsenceSerializer(serializers.ModelSerializer):
# In order to write with the id and read the entire object, it uses two fields field + field_id.
student = StudentSerializer(read_only=True)
student_id = serializers.PrimaryKeyRelatedField(queryset=StudentModel.objects.all(),
source='student', required=False, allow_null=True)
class Meta:
model = models.StudentAbsenceModel
exclude = ('datetime_creation', 'datetime_update',)
read_only_fields = ('user', 'username',)
def update(self, instance, validated_data):
if models.StudentAbsenceSettingsModel.objects.first().sync_with_proeco:
if not self.sync_proeco(instance, validated_data["is_absent"]):
raise
return super(StudentAbsenceSerializer, self).update(instance, validated_data)
@staticmethod
def sync_proeco(absence: models.StudentAbsenceModel, is_absent):
from libreschoolfdb import writer
server = [
s['server'] for s in settings.SYNC_FDB_SERVER
if s['teaching_name'] == absence.student.teaching.name
]
if len(server) != 0:
periods = models.PeriodModel.objects.all().order_by("start")
period = [i for i, p in enumerate(periods) if p.id == absence.period.id][0]
return writer.set_student_absence(
matricule=absence.student.matricule,
day=absence.date_absence,
period=period,
is_absent=is_absent,
fdb_server=server[0]
)
return False
def search_people(query, people_type, teachings, check_access, user):
def serialize_people(person):
if type(person) == StudentModel:
return StudentSerializer(person).data
elif type(person) == ResponsibleModel:
return ResponsibleSensitiveSerializer(person).data
if len(query) < 1:
return []
truncate_limit = 50
people = []
if people_type == 'responsible' or people_type == 'all':
people += ResponsibleSensitiveSerializer(
People().get_responsibles_by_name(query,
teachings)[:truncate_limit],
many=True).data
if people_type == 'teacher':
people += ResponsibleSensitiveSerializer(People().get_teachers_by_name(
query, teachings)[:truncate_limit],
many=True).data
if people_type == 'educator':
people += ResponsibleSensitiveSerializer(
People().get_educators_by_name(query, teachings)[:truncate_limit],
many=True).data
if people_type == 'student' or people_type == 'all':
classe_years = get_classes(teachings, check_access=True,
user=user) if check_access else None
people += StudentSerializer(People().get_students_by_name(
query, teachings, classes=classe_years)[:truncate_limit],
many=True).data
return people[:truncate_limit]
def search_people(query,
people_type,
teachings,
check_access,
user,
tenure_class_only=True,
educ_by_years=True,
active=True):
if len(query) < 1:
return []
truncate_limit = 50
people = []
if people_type == 'all':
classe_years = get_classes(teachings, check_access=True,
user=user) if check_access else None
result = People().get_people_by_name(query,
teachings,
classes=classe_years,
active=active)
# Check quality.
if result['student'][1] > result['responsible'][1]:
people = StudentSerializer(result['student'][0][:truncate_limit],
many=True).data
elif result['responsible'][1] > result['student'][1]:
people = ResponsibleSerializer(
result['responsible'][0][:truncate_limit], many=True).data
else:
people = StudentSerializer(
result['student'][0][:truncate_limit / 2],
many=True).data + ResponsibleSerializer(
result['responsible'][0][:truncate_limit / 2],
many=True).data
if people_type == 'student':
classe_years = get_classes(
teachings,
check_access=True,
user=user,
tenure_class_only=tenure_class_only,
educ_by_years=educ_by_years) if check_access else None
if query == 'everybody':
students = StudentModel.objects.all()
if active:
students = students.filter(inactive_from__isnull=True,
classe__isnull=False)
if classe_years:
students = students.filter(classe__in=classe_years)
if teachings and 'all' not in teachings:
if type(teachings[0]) == TeachingModel:
students = students.filter(teaching__in=teachings)
else:
students = students.filter(teaching__name__in=teachings)
truncate_limit = len(students)
else:
students = People().get_students_by_name(
query, teachings, classes=classe_years,
active=active)[:truncate_limit]
people = StudentSerializer(students, many=True).data
if people_type == 'responsible':
people = ResponsibleSerializer(People().get_responsibles_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
if people_type == 'teacher':
people = ResponsibleSerializer(People().get_teachers_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
if people_type == 'educator':
people = ResponsibleSerializer(People().get_educators_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
return people[:truncate_limit]
def list(request):
students = Student.objects.all()
# [Object to Json]
serial = StudentSerializer(instance=students, many=True)
return Res(serial.data, safe=False)