private void AddAbsences(List <StudentDomain> students, int selectedMonthId)
{
var absences = new List <AbsenceEntity>();
foreach (var student in students)
{
var studentAbsences = student.Absences.Where(x => x.MonthId < selectedMonthId).ToList();
var totalExcusedAbsences = studentAbsences.Sum(x => x.Excused);
var totalNotExcusedAbsences = studentAbsences.Sum(x => x.NotExcused);
var studentId = _encryptingService.DecodeId(student.Id);
var absence = new AbsenceEntity()
{
Excused = student.EnteredTotalExcusedAbsences - totalExcusedAbsences,
NotExcused = student.EnteredTotalNotExcusedAbsences - totalNotExcusedAbsences,
StudentId = studentId,
MonthId = selectedMonthId
};
absences.Add(absence);
}
_absenceRepository.AddRange(absences);
}
/// <summary>
/// Crea la lista de los alumnos que deben asistir a
/// clases.
/// </summary>
/// <param name="schoolClassIds">
/// array de ids de las clases.
/// </param>
/// <returns>
/// Retorna una lista de objetos SchoolClassStudent que pueden
/// contener objetos Absence en caso de que no sea la primera
/// vez que el profesor hace la peticion
/// </returns>
public async Task <List <SchoolClassStudent> > Get(int[] schoolClassIds)
{
List <SchoolClassStudent> callList = new List <SchoolClassStudent>();
foreach (int id in schoolClassIds)
{
//Alumnos que deben ir a cada clase
List <StudentEntity> studentEntities = await _studentRepository
.GetByCurrentSchoolClass(id);
foreach (StudentEntity s in studentEntities)
{
//Para cada alumno de la lista, se mira si ya ha sido marcado como
//ausente de la misma clase, en tal caso se instancia un objeto Absence dentro del objeto
//SchoolClassStudent para que el profesor no tenga que volver a marcar
//a los ausentes cuando recibe la lista
AbsenceEntity absenceEntity = await _absenceRepository
.GetByStudentAndSchoolClass(s.Id, id);
Absence absence = AbsenceMapper.Map(absenceEntity);
callList.Add(new SchoolClassStudent
{
SchoolClassId = id,
Absence = absence,
Student = StudentMapper.Map(s)
});
}
}
;
return(callList);
}
/// <summary>
/// Obtiene del repositorio la entidad AbsenceEntity correspondiente
/// al id y la envia de nuevo al repositorio para que la propriedad
/// isExcused sea modificada
/// </summary>
/// <param name="absenceId">
/// EL id de la ausencia
/// </param>
/// <param name="isExcused">
/// bool que indica si la ausencia debe ser justificada o no
/// </param>
/// <returns>
/// Retorna true
/// </returns>
public async Task <bool> SetExcused(int absenceId, bool isExcused)
{
AbsenceEntity absenceEntity = await _absenceRepository.Get(absenceId);
bool result = await _absenceRepository.SetExcused(absenceEntity, isExcused);
return(result);
}
/// <summary>
/// Justifica o no una ausencia modificando
/// el campo "isExcused" de una entidad ausencia
/// </summary>
/// <param name="absenceEntity"></param>
/// <param name="isExcused"></param>
/// <returns>
/// Retorna true
/// </returns>
public async Task <bool> SetExcused(AbsenceEntity absenceEntity, bool isExcused)
{
absenceEntity.IsExcused = isExcused;
await _dbContext.SaveChangesAsync();
_logger.LogInformation("Justificacion de la ausencia con id "
+ absenceEntity.Id + " actualizada");
return(true);
}
/// <summary>
/// Obtiene la ausencia de un alumno dado
/// su id ,el id de una clase y el día de hoy
/// </summary>
/// <param name="studentId"></param>
/// <param name="schoolClassId"></param>
/// <returns>
/// Retorna una entidad AbsenceEntity
/// </returns>
public async Task <AbsenceEntity> GetByStudentAndSchoolClass(int studentId, int schoolClassId)
{
AbsenceEntity entity = await _dbContext.AbsenceEntities
.FirstOrDefaultAsync(a => a.StudentId == studentId &&
a.SchoolClassId == schoolClassId &&
a.Date == DateTime.Today);
_logger.LogInformation("Ausencia del alumno con id "
+ studentId + " de la clase con id " + schoolClassId + " obtenida");
return(entity);
}
/// <summary>
/// Obtiene un registro de ausencia por su id
/// </summary>
/// <param name="absenceId"></param>
/// <exception cref="DataNotFoundException">
/// Lanza DataNotFoundException si el id no existe
/// </exception>
/// <returns>
/// Retorna una entidad AbsenceEntity
/// </returns>
public async Task <AbsenceEntity> Get(int absenceId)
{
AbsenceEntity absenceEntity = await _dbContext.AbsenceEntities.FirstOrDefaultAsync(a => a.Id == absenceId);
if (absenceEntity is null)
{
var message = "No se ha encontrado la ausencia, el id no existe";
throw new DataNotFoundException(message);
}
_logger.LogInformation("Ausencia con id " + absenceId + " obetenida de la base de datos");
return(absenceEntity);
}
/// <summary>
/// Mapea un objeto AbsenceEntity en un objeto Absence
/// </summary>
/// <param name="absenceEntity"></param>
/// <returns></returns>
public static Absence Map(AbsenceEntity absenceEntity)
{
if (absenceEntity is null)
{
return(null);
}
else
{
return(new Absence()
{
Id = absenceEntity.Id,
Type = absenceEntity.Type,
Date = absenceEntity.Date
});
}
}
/// <summary>
/// Mapea una entidad AbsenceEntity en un objeto Absence
/// incluyendo el objeto Schedule y el objeto Subject
/// </summary>
/// <param name="absenceEntity"></param>
/// <returns></returns>
public static Absence MapIncludingSchedule(AbsenceEntity absenceEntity)
{
if (absenceEntity is null)
{
return(null);
}
else
{
return(new Absence()
{
Id = absenceEntity.Id,
Type = absenceEntity.Type,
Date = absenceEntity.Date,
Schedule = ScheduleMapper.Map(absenceEntity.SchoolClassEntity.ScheduleEntity),
Subject = SubjectMapper.Map(absenceEntity.SchoolClassEntity.SubjectEntity),
IsExcused = absenceEntity.IsExcused
});
}
}
private void UpdateAbsebces(List <StudentDomain> students, int selectedMonthId)
{
foreach (var student in students)
{
var studentAbsences = student.Absences.Where(x => x.MonthId < selectedMonthId).ToList();
var totalExcusedAbsences = studentAbsences.Sum(x => x.Excused);
var totalNotExcusedAbsences = studentAbsences.Sum(x => x.NotExcused);
var studentId = _encryptingService.DecodeId(student.Id);
var studentAbsence = student.Absences.LastOrDefault();
if (studentAbsence != null)
{
var absenseId = _encryptingService.DecodeId(studentAbsence.Id);
var absence = new AbsenceEntity()
{
Id = absenseId,
Excused = student.EnteredTotalExcusedAbsences - totalExcusedAbsences,
NotExcused = student.EnteredTotalNotExcusedAbsences - totalNotExcusedAbsences,
StudentId = studentId,
MonthId = selectedMonthId
};
_absenceRepository.Update(absence);
}
//if user do not fill row when update record
else
{
var absence = new AbsenceEntity()
{
Excused = 0,
NotExcused = 0,
StudentId = studentId,
MonthId = selectedMonthId
};
_absenceRepository.Add(absence);
}
}
}
