/**
* Copyright © 2002 Instituto Superior Técnico
*
* This file is part of FenixEdu Academic.
*
* FenixEdu Academic is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* FenixEdu Academic is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with FenixEdu Academic. If not, see <http://www.gnu.org/licenses/>.
*/
package org.fenixedu.academic.domain.studentCurriculum;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import org.fenixedu.academic.domain.CurricularCourse;
import org.fenixedu.academic.domain.ExecutionSemester;
import org.fenixedu.academic.domain.ExecutionYear;
import org.fenixedu.academic.domain.Grade;
import org.fenixedu.academic.domain.IEnrolment;
import org.fenixedu.academic.domain.StudentCurricularPlan;
import org.fenixedu.academic.domain.degreeStructure.CourseGroup;
import org.fenixedu.academic.domain.degreeStructure.EctsTableIndex;
import org.fenixedu.academic.domain.degreeStructure.OptionalCurricularCourse;
import org.fenixedu.academic.domain.enrolment.DismissalCurriculumModuleWrapper;
import org.fenixedu.academic.domain.enrolment.IDegreeModuleToEvaluate;
import org.fenixedu.academic.domain.exceptions.DomainException;
import org.fenixedu.academic.domain.log.DismissalLog;
import org.fenixedu.academic.domain.student.curriculum.Curriculum;
import org.fenixedu.academic.domain.student.curriculum.ICurriculumEntry;
import org.fenixedu.academic.util.Bundle;
import org.fenixedu.academic.util.EnrolmentAction;
import org.fenixedu.bennu.core.i18n.BundleUtil;
import org.joda.time.DateTime;
import org.joda.time.YearMonthDay;
public class Dismissal extends Dismissal_Base implements ICurriculumEntry {
public Dismissal() {
super();
}
public Dismissal(Credits credits, CurriculumGroup curriculumGroup, CurricularCourse curricularCourse) {
init(credits, curriculumGroup, curricularCourse);
createCurriculumLineLog(EnrolmentAction.ENROL);
}
protected void init(Credits credits, CurriculumGroup curriculumGroup) {
if (credits == null || curriculumGroup == null) {
throw new DomainException("error.dismissal.wrong.arguments");
}
setCredits(credits);
setCurriculumGroup(curriculumGroup);
}
protected void init(final Credits credits, final CurriculumGroup curriculumGroup, final CurricularCourse curricularCourse) {
if (curricularCourse == null) {
throw new DomainException("error.dismissal.wrong.arguments");
}
checkCurriculumGroupCurricularCourse(credits, curriculumGroup, curricularCourse);
init(credits, curriculumGroup);
setCurricularCourse(curricularCourse);
}
private void checkCurriculumGroupCurricularCourse(final Credits credits, final CurriculumGroup curriculumGroup,
final CurricularCourse curricularCourse) {
if (!(curriculumGroup instanceof NoCourseGroupCurriculumGroup)) {
if (!curriculumGroup.getCurricularCoursesToDismissal(credits.getExecutionPeriod()).contains(curricularCourse)) {
throw new DomainException("error.dismissal.invalid.curricular.course.to.dismissal", curriculumGroup.getName()
.getContent(), curricularCourse.getName(), credits.getExecutionPeriod().getQualifiedName());
}
}
}
static protected Dismissal createNewDismissal(final Credits credits, final StudentCurricularPlan studentCurricularPlan,
final CourseGroup courseGroup, final Collection<CurricularCourse> noEnrolCurricularCourses) {
return new CreditsDismissal(credits, findCurriculumGroupForCourseGroup(studentCurricularPlan, courseGroup),
noEnrolCurricularCourses);
}
static protected Dismissal createNewDismissal(final Credits credits, final StudentCurricularPlan studentCurricularPlan,
final CurriculumGroup curriculumGroup, final Collection<CurricularCourse> noEnrolCurricularCourses) {
return new CreditsDismissal(credits, curriculumGroup, noEnrolCurricularCourses);
}
static private CurriculumGroup findCurriculumGroupForCourseGroup(final StudentCurricularPlan studentCurricularPlan,
final CourseGroup courseGroup) {
final CurriculumGroup curriculumGroup = studentCurricularPlan.findCurriculumGroupFor(courseGroup);
if (curriculumGroup != null) {
return curriculumGroup;
}
throw new DomainException("error.studentCurricularPlan.doesnot.have.courseGroup", courseGroup.getName());
}
static protected Dismissal createNewDismissal(final Credits credits, final StudentCurricularPlan studentCurricularPlan,
CurriculumGroup curriculumGroup, final CurricularCourse curricularCourse) {
return new Dismissal(credits, curriculumGroup, curricularCourse);
}
static protected Dismissal createNewOptionalDismissal(final Credits credits,
final StudentCurricularPlan studentCurricularPlan, CurriculumGroup curriculumGroup,
final OptionalCurricularCourse optionalCurricularCourse, final Double ectsCredits) {
return new OptionalDismissal(credits, curriculumGroup, optionalCurricularCourse, ectsCredits);
}
@Override
public StringBuilder print(String tabs) {
final StringBuilder builder = new StringBuilder();
builder.append(tabs);
builder.append("[D ").append(getDegreeModule() != null ? getDegreeModule().getName() : "").append(" ");
builder.append(getEctsCredits()).append(" ects ]\n");
return builder;
}
@Override
public boolean isApproved() {
return true;
}
@Override
public boolean isValid(final ExecutionSemester executionSemester) {
return hasExecutionPeriod() && getExecutionPeriod().equals(executionSemester);
}
@Override
final public ExecutionYear getIEnrolmentsLastExecutionYear() {
ExecutionYear result = null;
for (final IEnrolment iEnrolment : this.getSourceIEnrolments()) {
final ExecutionYear executionYear = iEnrolment.getExecutionYear();
if (result == null || result.isBefore(executionYear)) {
result = executionYear;
}
}
return result;
}
public Collection<IEnrolment> getSourceIEnrolments() {
return getCredits().getIEnrolments();
}
final public boolean hasSourceIEnrolments(final IEnrolment iEnrolment) {
return getCredits().hasIEnrolments(iEnrolment);
}
@Override
public boolean isApproved(final CurricularCourse curricularCourse, final ExecutionSemester executionSemester) {
return (executionSemester == null || !hasExecutionPeriod() || getExecutionPeriod().isBeforeOrEquals(executionSemester))
&& hasCurricularCourse(getCurricularCourse(), curricularCourse, executionSemester);
}
@Override
public Double getEctsCredits() {
// FIXME must migrate Dismissal with optional curricular courses to
// OptionalDismissal
return getCurricularCourse().isOptionalCurricularCourse() ? getEnrolmentsEcts() : getCurricularCourse().getEctsCredits(
getExecutionPeriod());
}
@Override
final public BigDecimal getEctsCreditsForCurriculum() {
return BigDecimal.valueOf(getEctsCredits());
}
@Override
public double getAccumulatedEctsCredits(final ExecutionSemester executionSemester) {
return getEctsCredits().doubleValue();
}
protected Double getEnrolmentsEcts() {
return getCredits().getEnrolmentsEcts();
}
@Override
public Double getAprovedEctsCredits() {
return isExtraCurricular() ? Double.valueOf(0d) : getEctsCredits();
}
@Override
public Double getEnroledEctsCredits(final ExecutionSemester executionSemester) {
return Double.valueOf(0d);
}
@Override
public void collectDismissals(final List<Dismissal> result) {
result.add(this);
}
@Override
public boolean isDismissal() {
return true;
}
public boolean isSimilar(final Dismissal dismissal) {
return hasSameDegreeModules(dismissal) && hasSameSourceIEnrolments(getSourceIEnrolments(), dismissal);
}
protected boolean hasSameDegreeModules(final Dismissal dismissal) {
return (getDegreeModule() == dismissal.getDegreeModule() || getCurricularCourse().isEquivalent(
dismissal.getCurricularCourse()));
}
protected boolean hasSameSourceIEnrolments(final Collection<IEnrolment> ienrolments, final Dismissal dismissal) {
return ienrolments.containsAll(dismissal.getSourceIEnrolments())
&& ienrolments.size() == dismissal.getSourceIEnrolments().size();
}
@Override
public Dismissal getDismissal(final CurricularCourse curricularCourse) {
return (getCurricularCourse() == curricularCourse) ? this : null;
}
void deleteFromCredits() {
createCurriculumLineLog(EnrolmentAction.UNENROL);
setCredits(null);
super.delete();
}
@Override
public void delete() {
createCurriculumLineLog(EnrolmentAction.UNENROL);
final Credits credits = getCredits();
setCredits(null);
if (credits != null && credits.getDismissalsSet().isEmpty()) {
credits.delete();
}
super.delete();
}
@Override
public ConclusionValue isConcluded(final ExecutionYear executionYear) {
return ConclusionValue.create(executionYear == null || !hasExecutionPeriod()
|| getExecutionPeriod().getExecutionYear().isBeforeOrEquals(executionYear));
}
@Override
public Double getCreditsConcluded(ExecutionYear executionYear) {
return isConcluded(executionYear).value() && !getCredits().isTemporary() ? getEctsCredits() : Double.valueOf(0d);
}
@Override
public YearMonthDay calculateConclusionDate() {
final SortedSet<IEnrolment> iEnrolments = new TreeSet<IEnrolment>(IEnrolment.COMPARATOR_BY_APPROVEMENT_DATE);
iEnrolments.addAll(getSourceIEnrolments());
final YearMonthDay beginDate = getExecutionPeriod().getBeginDateYearMonthDay();
if (!iEnrolments.isEmpty()) {
final IEnrolment enrolment = iEnrolments.last();
final YearMonthDay approvementDate = enrolment.getApprovementDate();
return approvementDate != null ? approvementDate : beginDate;
} else {
return beginDate;
}
}
@Override
@SuppressWarnings("unchecked")
final public Curriculum getCurriculum(final DateTime when, final ExecutionYear year) {
if (wasCreated(when) && (year == null || !hasExecutionPeriod() || getExecutionYear().isBeforeOrEquals(year))) {
final Collection<ICurriculumEntry> averageEntries = getAverageEntries(year);
if (!averageEntries.isEmpty() || getCredits().isCredits()) {
return new Curriculum(this, year, Collections.EMPTY_SET, averageEntries,
Collections.singleton((ICurriculumEntry) this));
}
} else if (getCredits().isInternalSubstitution()) {
return getCredits().getCurriculum(this, when, year);
}
return Curriculum.createEmpty(this, year);
}
private Collection<ICurriculumEntry> getAverageEntries(final ExecutionYear year) {
if (getCredits().isEquivalence() && (year == null || !hasExecutionPeriod() || getExecutionYear().isBefore(year))) {
return Collections.singleton((ICurriculumEntry) this);
}
return getCredits().getAverageEntries(year);
}
@Override
public Grade getGrade() {
return getCredits().isEquivalence() ? getCredits().getGrade() : Grade.createEmptyGrade();
}
@Override
public String getGradeValue() {
return getGrade().getValue();
}
public Double getWeigth() {
return getCredits().isEquivalence() ? getEctsCredits() : null;
}
@Override
final public BigDecimal getWeigthForCurriculum() {
return BigDecimal.valueOf(getWeigth());
}
@Override
public BigDecimal getWeigthTimesGrade() {
return getCredits().isEquivalence() && getGrade().isNumeric() ? getWeigthForCurriculum().multiply(
getGrade().getNumericValue()) : BigDecimal.ZERO;
}
@Override
public String getCode() {
return hasCurricularCourse() ? getCurricularCourse().getCode() : null;
}
@Override
public ExecutionSemester getExecutionPeriod() {
return getCredits().getExecutionPeriod();
}
@Override
public Set<IDegreeModuleToEvaluate> getDegreeModulesToEvaluate(ExecutionSemester executionSemester) {
if (executionSemester != null && executionSemester != getExecutionPeriod()) {
return Collections.EMPTY_SET;
}
final Set<IDegreeModuleToEvaluate> result = new HashSet<IDegreeModuleToEvaluate>(1);
result.add(new DismissalCurriculumModuleWrapper(this, executionSemester));
return result;
}
@Override
protected void createCurriculumLineLog(final EnrolmentAction action) {
new DismissalLog(action, getRegistration(), getCurricularCourse(), getCredits(), getExecutionPeriod(), getCurrentUser());
}
public Grade getEctsGrade(DateTime processingDate) {
return EctsTableIndex.convertGradeToEcts(getCurricularCourse(), this, getGrade(), processingDate);
}
public String getEnrolmentTypeName() {
if (isExtraCurricular()) {
return "EXTRA_CURRICULAR_ENROLMENT";
} else if (isOptional()) {
return "ENROLMENT_IN_OPTIONAL_DEGREE_MODULE";
} else {
return "COMPULSORY_ENROLMENT";
}
}
public boolean isAnual() {
final CurricularCourse curricularCourse = getCurricularCourse();
return curricularCourse != null && curricularCourse.isAnual();
}
@Override
public String getModuleTypeName() {
return BundleUtil.getString(Bundle.ENUMERATION, this.getClass().getName());
}
}