@Service
public static InfoSiteStudentsAndGroups run(Integer groupingId) throws FenixServiceException {
InfoSiteStudentsAndGroups infoSiteStudentsAndGroups = new InfoSiteStudentsAndGroups();
Grouping grouping = rootDomainObject.readGroupingByOID(groupingId);
if (grouping == null) {
throw new ExistingServiceException();
}
List infoSiteStudentsAndGroupsList = new ArrayList();
List studentGroups = getAllStudentGroups(grouping);
Iterator iterStudentGroups = studentGroups.iterator();
while (iterStudentGroups.hasNext()) {
List studentGroupAttendList = new ArrayList();
StudentGroup studentGroup = (StudentGroup) iterStudentGroups.next();
studentGroupAttendList = studentGroup.getAttends();
Iterator iterStudentGroupAttendList = studentGroupAttendList.iterator();
InfoSiteStudentInformation infoSiteStudentInformation = null;
InfoSiteStudentAndGroup infoSiteStudentAndGroup = null;
Attends attend = null;
while (iterStudentGroupAttendList.hasNext()) {
infoSiteStudentInformation = new InfoSiteStudentInformation();
infoSiteStudentAndGroup = new InfoSiteStudentAndGroup();
attend = (Attends) iterStudentGroupAttendList.next();
infoSiteStudentAndGroup.setInfoStudentGroup(
InfoStudentGroup.newInfoFromDomain(studentGroup));
infoSiteStudentInformation.setNumber(attend.getRegistration().getNumber());
infoSiteStudentInformation.setName(attend.getRegistration().getPerson().getName());
infoSiteStudentInformation.setUsername(
(attend.getRegistration().getPerson().getUsername()));
infoSiteStudentInformation.setEmail(attend.getRegistration().getPerson().getEmail());
infoSiteStudentInformation.setPersonID(
attend.getRegistration().getPerson().getIdInternal());
infoSiteStudentAndGroup.setInfoSiteStudentInformation(infoSiteStudentInformation);
infoSiteStudentsAndGroupsList.add(infoSiteStudentAndGroup);
}
}
Collections.sort(
infoSiteStudentsAndGroupsList, new BeanComparator("infoStudentGroup.groupNumber"));
infoSiteStudentsAndGroups.setInfoSiteStudentsAndGroupsList(infoSiteStudentsAndGroupsList);
infoSiteStudentsAndGroups.setInfoGrouping(InfoGrouping.newInfoFromDomain(grouping));
return infoSiteStudentsAndGroups;
}
private static Attends findAttend(
final ExecutionCourse executionCourse,
final Integer studentNumber,
final List<DomainException> exceptionList) {
final List<Attends> activeAttends = new ArrayList<Attends>(2);
for (final Attends attend : executionCourse.getAttends()) {
if (attend.getRegistration().getNumber().equals(studentNumber)
&& (isActive(attend) || belongsToActiveExternalCycle(attend))) {
activeAttends.add(attend);
}
}
if (activeAttends.size() == 1) {
return activeAttends.iterator().next();
}
if (activeAttends.isEmpty()) {
exceptionList.add(
new DomainException("errors.student.without.active.attends", studentNumber.toString()));
} else {
exceptionList.add(
new DomainException(
"errors.student.with.several.active.attends", studentNumber.toString()));
}
return null;
}
private static Attends findAttend(final ExecutionCourse executionCourse, final String attendId) {
for (final Attends attend : executionCourse.getAttends()) {
if (attend.getExternalId().equals(attendId)) {
return attend;
}
}
return null;
}
public static boolean studentHasSomeAttendsInGrouping(
final Registration registration, final Grouping groupProperties) {
for (final Attends attends : groupProperties.getAttendsSet()) {
final Registration otherRegistration = attends.getRegistration();
if (registration == otherRegistration) {
return true;
}
}
return false;
}
protected Boolean run(
String executionCourseID,
String studentGroupID,
String groupPropertiesID,
List studentUsernames)
throws FenixServiceException {
final StudentGroup studentGroup = FenixFramework.getDomainObject(studentGroupID);
if (studentGroup == null) {
throw new InvalidArgumentsServiceException();
}
final Grouping grouping = studentGroup.getGrouping();
final IGroupEnrolmentStrategyFactory enrolmentGroupPolicyStrategyFactory =
GroupEnrolmentStrategyFactory.getInstance();
final IGroupEnrolmentStrategy strategy =
enrolmentGroupPolicyStrategyFactory.getGroupEnrolmentStrategyInstance(grouping);
if (!strategy.checkStudentsUserNamesInGrouping(studentUsernames, grouping)) {
throw new InvalidArgumentsServiceException();
}
StringBuilder sbStudentNumbers = new StringBuilder("");
sbStudentNumbers.setLength(0);
for (final String studentUsername : (List<String>) studentUsernames) {
Attends attend = grouping.getStudentAttend(studentUsername);
if (attend != null) {
if (sbStudentNumbers.length() != 0) {
sbStudentNumbers.append(", " + attend.getRegistration().getNumber().toString());
} else {
sbStudentNumbers.append(attend.getRegistration().getNumber().toString());
}
attend.removeStudentGroups(studentGroup);
}
}
// no students means no log entry -- list may contain invalid values, so
// its size cannot be used to test
if (sbStudentNumbers.length() != 0) {
List<ExecutionCourse> ecs = grouping.getExecutionCourses();
for (ExecutionCourse ec : ecs) {
GroupsAndShiftsManagementLog.createLog(
ec,
"resources.MessagingResources",
"log.executionCourse.groupAndShifts.grouping.group.element.removed",
Integer.toString(studentUsernames.size()),
sbStudentNumbers.toString(),
studentGroup.getGroupNumber().toString(),
grouping.getName(),
ec.getNome(),
ec.getDegreePresentationString());
}
}
return true;
}
private static boolean belongsToActiveExternalCycle(final Attends attend) {
if (attend.hasEnrolment()) {
final CycleCurriculumGroup cycle = attend.getEnrolment().getParentCycleCurriculumGroup();
if (cycle != null && cycle.isExternal()) {
final Student student = attend.getRegistration().getStudent();
return student.getActiveRegistrationFor(cycle.getDegreeCurricularPlanOfDegreeModule())
!= null;
}
}
return false;
}
protected Boolean run(String objectCode, String groupingCode) throws FenixServiceException {
Grouping grouping = FenixFramework.getDomainObject(groupingCode);
if (grouping == null) {
throw new ExistingServiceException();
}
List attendsElements = new ArrayList();
attendsElements.addAll(grouping.getAttends());
Iterator iterator = attendsElements.iterator();
StringBuilder sbStudentNumbers = new StringBuilder("");
sbStudentNumbers.setLength(0);
while (iterator.hasNext()) {
Attends attend = (Attends) iterator.next();
if (sbStudentNumbers.length() != 0) {
sbStudentNumbers.append(", " + attend.getRegistration().getNumber().toString());
} else {
sbStudentNumbers.append(attend.getRegistration().getNumber().toString());
}
boolean found = false;
Iterator iterStudentsGroups = grouping.getStudentGroupsSet().iterator();
while (iterStudentsGroups.hasNext() && !found) {
StudentGroup studentGroup = (StudentGroup) iterStudentsGroups.next();
if (studentGroup != null) {
studentGroup.removeAttends(attend);
found = true;
}
}
grouping.removeAttends(attend);
}
// no students means no log entry -- list may contain invalid values, so
// its size cannot be used to test
if (sbStudentNumbers.length() != 0) {
List<ExecutionCourse> ecs = grouping.getExecutionCourses();
for (ExecutionCourse ec : ecs) {
GroupsAndShiftsManagementLog.createLog(
ec,
"resources.MessagingResources",
"log.executionCourse.groupAndShifts.grouping.memberSet.removed",
Integer.toString(attendsElements.size()),
sbStudentNumbers.toString(),
grouping.getName(),
ec.getNome(),
ec.getDegreePresentationString());
}
}
return true;
}
private static boolean isActive(final Attends attends) {
final RegistrationState state;
if (attends.hasEnrolment()) {
state =
attends
.getEnrolment()
.getRegistration()
.getLastRegistrationState(attends.getExecutionYear());
} else {
state = attends.getRegistration().getLastRegistrationState(attends.getExecutionYear());
}
return state != null && state.isActive();
}
private static void writeMarks(
final List<AttendsMark> marks,
final ExecutionCourse executionCourse,
final Evaluation evaluation)
throws FenixServiceMultipleException {
final List<DomainException> exceptionList = new ArrayList<DomainException>();
for (final AttendsMark entry : marks) {
final Attends attend = findAttend(executionCourse, entry.attendId);
final String markValue = entry.mark;
if (attend.hasEnrolment() && attend.getEnrolment().isImpossible()) {
exceptionList.add(
new DomainException(
"errors.student.with.impossible.enrolment",
attend.getRegistration().getStudent().getNumber().toString()));
} else {
final Mark mark = attend.getMarkByEvaluation(evaluation);
if (isToDeleteMark(markValue)) {
if (mark != null) {
mark.delete();
}
} else {
try {
if (mark == null) {
evaluation.addNewMark(attend, markValue);
} else {
mark.setMark(markValue);
}
} catch (InvalidMarkDomainException e) {
exceptionList.add(e);
}
}
}
}
if (!exceptionList.isEmpty()) {
throw new FenixServiceMultipleException(exceptionList);
}
EvaluationManagementLog.createLog(
executionCourse,
"resources.MessagingResources",
"log.executionCourse.evaluation.generic.edited.marks",
evaluation.getPresentationName(),
executionCourse.getName(),
executionCourse.getDegreePresentationString());
}
private static List<AttendsMark> convertMarks(
final ExecutionCourse executionCourse, final List<StudentMark> marks)
throws FenixServiceMultipleException {
final List<DomainException> exceptionList = new ArrayList<DomainException>();
final List<AttendsMark> result = new ArrayList<AttendsMark>();
for (final StudentMark studentMark : marks) {
final Attends attend = findAttend(executionCourse, studentMark.studentNumber, exceptionList);
if (attend != null) {
result.add(new AttendsMark(attend.getExternalId(), studentMark.mark));
}
}
if (!exceptionList.isEmpty()) {
throw new FenixServiceMultipleException(exceptionList);
}
return result;
}
private static void addMark(
List<AttendsMark> result,
StudentMark studentMark,
Attends attend,
List<DomainException> exceptionList) {
if (studentMark.mark.length() - studentMark.mark.indexOf('.') - 1 > 2) {
exceptionList.add(
new DomainException("error.mark.more.than.two.decimals", studentMark.studentNumber));
} else {
result.add(new AttendsMark(attend.getExternalId(), studentMark.mark));
}
}
protected Set<Teacher> getTeachers(List<ExecutionSemester> executionSemesters) {
Set<Teacher> teachers = new HashSet<Teacher>();
ExecutionYear previousExecutionYear =
executionSemester.getExecutionYear().getPreviousExecutionYear();
for (final DegreeCurricularPlan degreeCurricularPlan : degree.getDegreeCurricularPlansSet()) {
for (final CurricularCourse course : degreeCurricularPlan.getCurricularCourses()) {
for (final ExecutionCourse executionCourse : course.getAssociatedExecutionCourses()) {
if (executionSemesters.contains(executionCourse.getExecutionPeriod())) {
for (Professorship professorhip : executionCourse.getProfessorshipsSet()) {
if (professorhip
.getPerson()
.getTeacher()
.isActiveOrHasAuthorizationForSemester(executionCourse.getExecutionPeriod())) {
teachers.add(professorhip.getPerson().getTeacher());
}
}
}
if (previousExecutionYear.equals(
executionCourse.getExecutionPeriod().getExecutionYear())) {
if (executionCourse.isDissertation()) {
for (Attends attends : executionCourse.getAttends()) {
if (attends.hasEnrolment() && attends.getEnrolment().getThesis() != null) {
for (ThesisEvaluationParticipant thesisEvaluationParticipant :
attends.getEnrolment().getThesis().getOrientation()) {
if (thesisEvaluationParticipant.getPerson().getTeacher() != null
&& thesisEvaluationParticipant
.getPerson()
.getTeacher()
.isActiveOrHasAuthorizationForSemester(
executionCourse.getExecutionPeriod())) {
teachers.add(thesisEvaluationParticipant.getPerson().getTeacher());
}
}
}
}
}
}
}
}
}
PhdProgram phdProgram = degree.getPhdProgram();
if (phdProgram != null) {
for (PhdIndividualProgramProcess phdIndividualProgramProcess :
phdProgram.getIndividualProgramProcesses()) {
for (ExecutionSemester executionSemester : executionSemesters) {
if (phdIndividualProgramProcess.isActive(
executionSemester.getAcademicInterval().toInterval())) {
for (PhdParticipant phdParticipant : phdIndividualProgramProcess.getParticipants()) {
if (phdParticipant instanceof InternalPhdParticipant) {
InternalPhdParticipant internalPhdParticipant =
(InternalPhdParticipant) phdParticipant;
if (internalPhdParticipant.isGuidingOrAssistantGuiding()
&& internalPhdParticipant.getPerson().getTeacher() != null
&& internalPhdParticipant
.getPerson()
.getTeacher()
.isActiveOrHasAuthorizationForSemester(executionSemester)) {
teachers.add(internalPhdParticipant.getPerson().getTeacher());
}
}
}
}
}
}
}
return teachers;
}
private String getTeachersAndTeachingHours(CurricularCourse course, boolean responsibleTeacher) {
Map<Teacher, Double> responsiblesMap = new HashMap<Teacher, Double>();
List<ExecutionSemester> executionSemesters = getSelectedExecutionSemesters();
for (final ExecutionCourse executionCourse : course.getAssociatedExecutionCourses()) {
if (executionSemesters.contains(executionCourse.getExecutionPeriod())) {
for (Professorship professorhip : executionCourse.getProfessorshipsSet()) {
if (professorhip.isResponsibleFor() == responsibleTeacher
&& professorhip
.getPerson()
.getTeacher()
.isActiveOrHasAuthorizationForSemester(executionCourse.getExecutionPeriod())) {
Double hours = responsiblesMap.get(professorhip.getTeacher());
if (hours == null) {
hours = 0.0;
}
hours = hours + getHours(professorhip);
responsiblesMap.put(professorhip.getTeacher(), hours);
}
}
}
}
int counter = 1000;
List<String> responsibles = new ArrayList<String>();
for (Teacher teacher : responsiblesMap.keySet()) {
String responsible =
teacher.getPerson().getName() + " (" + responsiblesMap.get(teacher) + ")";
counter -= JSONObject.escape(responsible + ", ").getBytes().length;
responsibles.add(responsible);
}
if (!responsibleTeacher && course.isDissertation()) {
Set<Teacher> teachers = new HashSet<Teacher>();
for (ExecutionCourse executionCourse : course.getAssociatedExecutionCoursesSet()) {
if (executionCourse
.getExecutionPeriod()
.getExecutionYear()
.equals(executionSemester.getExecutionYear().getPreviousExecutionYear())) {
for (Attends attends : executionCourse.getAttends()) {
if (attends.hasEnrolment() && attends.getEnrolment().getThesis() != null) {
for (ThesisEvaluationParticipant thesisEvaluationParticipant :
attends.getEnrolment().getThesis().getOrientation()) {
if (thesisEvaluationParticipant.getPerson().getTeacher() != null
&& thesisEvaluationParticipant
.getPerson()
.getTeacher()
.isActiveOrHasAuthorizationForSemester(
executionCourse.getExecutionPeriod())) {
teachers.add(thesisEvaluationParticipant.getPerson().getTeacher());
}
}
}
}
}
}
for (Teacher teacher : teachers) {
String responsible = teacher.getPerson().getName() + " (0.0)";
if (counter - JSONObject.escape(responsible).getBytes().length < 0) {
break;
}
if (!responsiblesMap.containsKey(teacher)) {
counter -= JSONObject.escape(responsible + ", ").getBytes().length;
responsibles.add(responsible);
}
}
}
return StringUtils.join(responsibles, ", ");
}