/**
* 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.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import org.apache.commons.collections.comparators.ReverseComparator;
import org.fenixedu.academic.domain.ExecutionSemester;
import org.fenixedu.academic.domain.ExecutionYear;
import org.fenixedu.academic.domain.StudentCurricularPlan;
import org.fenixedu.academic.domain.curricularRules.CurricularRuleType;
import org.fenixedu.academic.domain.curricularRules.ICurricularRule;
import org.fenixedu.academic.domain.degree.DegreeType;
import org.fenixedu.academic.domain.degreeStructure.CycleCourseGroup;
import org.fenixedu.academic.domain.degreeStructure.CycleType;
import org.fenixedu.academic.domain.degreeStructure.DegreeModule;
import org.fenixedu.academic.domain.degreeStructure.RootCourseGroup;
import org.fenixedu.academic.domain.exceptions.DomainException;
import org.fenixedu.academic.domain.student.curriculum.Curriculum;
import org.joda.time.DateTime;
/**
*
* @author - Shezad Anavarali (shezad@ist.utl.pt)
*
*/
public class RootCurriculumGroup extends RootCurriculumGroup_Base {
protected RootCurriculumGroup() {
super();
createExtraCurriculumGroup();
createPropaedeuticsCurriculumGroup();
}
protected RootCurriculumGroup(StudentCurricularPlan studentCurricularPlan, RootCourseGroup rootCourseGroup,
ExecutionSemester executionSemester, CycleType cycleType) {
this();
init(studentCurricularPlan, rootCourseGroup, executionSemester, cycleType);
createStandaloneCurriculumGroupIfNecessary();
}
private void init(StudentCurricularPlan studentCurricularPlan, RootCourseGroup courseGroup,
ExecutionSemester executionSemester, CycleType cycleType) {
checkParameters(studentCurricularPlan, courseGroup, executionSemester);
checkInitConstraints(studentCurricularPlan, courseGroup);
setParentStudentCurricularPlan(studentCurricularPlan);
setDegreeModule(courseGroup);
addChildCurriculumGroups(courseGroup, executionSemester, cycleType);
}
private void checkParameters(final StudentCurricularPlan studentCurricularPlan, final RootCourseGroup courseGroup,
final ExecutionSemester executionSemester) {
checkParameters(studentCurricularPlan, courseGroup);
if (executionSemester == null) {
throw new DomainException("error.studentCurriculum.executionPeriod.cannot.be.null");
}
}
protected RootCurriculumGroup(StudentCurricularPlan studentCurricularPlan, RootCourseGroup rootCourseGroup,
CycleType cycleType) {
this();
init(studentCurricularPlan, rootCourseGroup, cycleType);
createStandaloneCurriculumGroupIfNecessary();
}
private void init(final StudentCurricularPlan studentCurricularPlan, final RootCourseGroup rootCourseGroup,
final CycleType cycleType) {
checkParameters(studentCurricularPlan, rootCourseGroup);
checkInitConstraints(studentCurricularPlan, rootCourseGroup);
setParentStudentCurricularPlan(studentCurricularPlan);
setDegreeModule(rootCourseGroup);
addChildCurriculumGroups(rootCourseGroup, cycleType);
}
private void checkParameters(final StudentCurricularPlan studentCurricularPlan, final RootCourseGroup rootCourseGroup) {
if (studentCurricularPlan == null) {
throw new DomainException("error.studentCurriculum.studentCurricularPlan.cannot.be.null");
}
if (rootCourseGroup == null) {
throw new DomainException("error.studentCurriculum.rootCourseGroup.cannot.be.null");
}
}
private void addChildCurriculumGroups(final RootCourseGroup rootCourseGroup, final ExecutionSemester executionSemester,
CycleType cycle) {
if (rootCourseGroup.hasCycleGroups()) {
createCycle(rootCourseGroup, executionSemester, cycle);
} else {
super.addChildCurriculumGroups(rootCourseGroup, executionSemester);
}
}
private void addChildCurriculumGroups(final RootCourseGroup rootCourseGroup, CycleType cycle) {
if (rootCourseGroup.hasCycleGroups()) {
createCycle(rootCourseGroup, null, cycle);
}
}
private void createCycle(final RootCourseGroup rootCourseGroup, final ExecutionSemester executionSemester, CycleType cycle) {
if (cycle == null) {
cycle = rootCourseGroup.getDegree().getDegreeType().getFirstOrderedCycleType();
}
if (cycle != null) {
CurriculumGroupFactory.createGroup(this, rootCourseGroup.getCycleCourseGroup(cycle), executionSemester);
}
}
private void checkInitConstraints(final StudentCurricularPlan studentCurricularPlan, final RootCourseGroup rootCourseGroup) {
if (studentCurricularPlan.getDegreeCurricularPlan() != rootCourseGroup.getParentDegreeCurricularPlan()) {
throw new DomainException("error.rootCurriculumGroup.scp.and.root.have.different.degreeCurricularPlan");
}
}
public void setRootCourseGroup(final RootCourseGroup rootCourseGroup) {
setDegreeModule(rootCourseGroup);
}
@Override
public void setDegreeModule(DegreeModule degreeModule) {
if (degreeModule != null && !(degreeModule instanceof RootCourseGroup)) {
throw new DomainException("error.curriculumGroup.RootCurriculumGroup.degreeModuleMustBeRootCourseGroup");
}
super.setDegreeModule(degreeModule);
}
@Override
public void setCurriculumGroup(CurriculumGroup curriculumGroup) {
if (curriculumGroup != null) {
throw new DomainException("error.curriculumGroup.RootCurriculumGroupCannotHaveParent");
}
}
@Override
public boolean isRoot() {
return true;
}
@Override
public StudentCurricularPlan getStudentCurricularPlan() {
return getParentStudentCurricularPlan();
}
public boolean hasStudentCurricularPlan() {
return getParentStudentCurricularPlan() != null;
}
private void createExtraCurriculumGroup() {
NoCourseGroupCurriculumGroup.create(NoCourseGroupCurriculumGroupType.EXTRA_CURRICULAR, this);
}
private void createPropaedeuticsCurriculumGroup() {
NoCourseGroupCurriculumGroup.create(NoCourseGroupCurriculumGroupType.PROPAEDEUTICS, this);
}
private void createStandaloneCurriculumGroupIfNecessary() {
if (hasStudentCurricularPlan() && getStudentCurricularPlan().isEmptyDegree()) {
NoCourseGroupCurriculumGroup.create(NoCourseGroupCurriculumGroupType.STANDALONE, this);
}
}
public CycleCurriculumGroup getCycleCurriculumGroup(CycleType cycleType) {
for (CurriculumModule curriculumModule : getCurriculumModulesSet()) {
if (curriculumModule.isCycleCurriculumGroup()) {
CycleCurriculumGroup cycleCurriculumGroup = (CycleCurriculumGroup) curriculumModule;
if (cycleCurriculumGroup.isCycle(cycleType)) {
return cycleCurriculumGroup;
}
}
}
return null;
}
public CycleCurriculumGroup getFirstOrderedCycleCurriculumGroup() {
for (final CycleType cycleType : getDegreeType().getOrderedCycleTypes()) {
CycleCurriculumGroup cycleCurriculumGroup = getCycleCurriculumGroup(cycleType);
if (cycleCurriculumGroup != null) {
return cycleCurriculumGroup;
}
}
return null;
}
public CycleCurriculumGroup getLastOrderedCycleCurriculumGroup() {
final SortedSet<CycleCurriculumGroup> cycleCurriculumGroups =
new TreeSet<CycleCurriculumGroup>(CycleCurriculumGroup.COMPARATOR_BY_CYCLE_TYPE_AND_ID);
cycleCurriculumGroups.addAll(getInternalCycleCurriculumGroups());
return cycleCurriculumGroups.isEmpty() ? null : cycleCurriculumGroups.last();
}
public CycleCurriculumGroup getLastConcludedCycleCurriculumGroup() {
final SortedSet<CycleCurriculumGroup> cycleCurriculumGroups =
new TreeSet<CycleCurriculumGroup>(new ReverseComparator(CycleCurriculumGroup.COMPARATOR_BY_CYCLE_TYPE_AND_ID));
cycleCurriculumGroups.addAll(getInternalCycleCurriculumGroups());
for (final CycleCurriculumGroup curriculumGroup : cycleCurriculumGroups) {
if (curriculumGroup.isConcluded()) {
return curriculumGroup;
}
}
return null;
}
public Collection<CycleCurriculumGroup> getCycleCurriculumGroups() {
Collection<CycleCurriculumGroup> cycleCurriculumGroups = new HashSet<CycleCurriculumGroup>();
for (CurriculumModule curriculumModule : getCurriculumModulesSet()) {
if (curriculumModule.isCycleCurriculumGroup()) {
cycleCurriculumGroups.add((CycleCurriculumGroup) curriculumModule);
}
}
return cycleCurriculumGroups;
}
public DegreeType getDegreeType() {
return getStudentCurricularPlan().getDegreeType();
}
/**
* Must not implement this method depending on
* hasConcludedCycle(CycleType,ExecutionYear). Each group knows what
* ExecutionYear to invoke by internal invocation of the
* getApprovedCurriculumLinesLastExecutionYear() method.
*
*/
public boolean hasConcludedCycle(CycleType cycleType) {
for (CycleType degreeCycleType : getDegreeType().getCycleTypes()) {
if (cycleType == null || degreeCycleType == cycleType) {
if (!checkIfCycleIsConcluded(degreeCycleType)) {
return false;
}
}
}
return cycleType == null || getDegreeType().getCycleTypes().contains(cycleType);
}
private boolean checkIfCycleIsConcluded(CycleType cycleType) {
final CycleCurriculumGroup cycleCurriculumGroup = getCycleCurriculumGroup(cycleType);
return cycleCurriculumGroup != null && cycleCurriculumGroup.isConcluded();
}
public boolean hasConcludedCycle(CycleType cycleType, final ExecutionYear executionYear) {
for (CycleType degreeCycleType : getDegreeType().getCycleTypes()) {
if (cycleType == null || degreeCycleType == cycleType) {
if (!checkIfCycleIsConcluded(degreeCycleType, executionYear)) {
return false;
}
}
}
return cycleType == null || getDegreeType().getCycleTypes().contains(cycleType);
}
private boolean checkIfCycleIsConcluded(CycleType cycleType, final ExecutionYear executionYear) {
final CycleCurriculumGroup cycleCurriculumGroup = getCycleCurriculumGroup(cycleType);
return cycleCurriculumGroup != null && cycleCurriculumGroup.isConcluded(executionYear).value();
}
/**
* Only the DegreeType's CycleTypes should be inspected.
* CycleCurriculumGroups of other CycleType might exist and shouldn't be
* taken into account.
*
*/
@Override
public Curriculum getCurriculum(final DateTime when, final ExecutionYear executionYear) {
final Curriculum curriculum = Curriculum.createEmpty(this, executionYear);
if (!wasCreated(when)) {
return curriculum;
}
final DegreeType degreeType = getDegreeType();
if (degreeType.hasAnyCycleTypes()) {
for (final CycleCurriculumGroup cycleCurriculumGroup : getInternalCycleCurriculumGroups()) {
curriculum.add(cycleCurriculumGroup.getCurriculum(when, executionYear));
}
} else {
curriculum.add(super.getCurriculum(when, executionYear));
}
return curriculum;
}
@Override
public void delete() {
setParentStudentCurricularPlan(null);
super.delete();
}
@Override
public RootCourseGroup getDegreeModule() {
return (RootCourseGroup) super.getDegreeModule();
}
public boolean hasExternalCycles() {
for (final CycleCurriculumGroup cycleCurriculumGroup : getCycleCurriculumGroups()) {
if (cycleCurriculumGroup.isExternal()) {
return true;
}
}
return false;
}
@Override
public ICurricularRule getMostRecentActiveCurricularRule(final CurricularRuleType ruleType, final ExecutionYear executionYear) {
return getDegreeModule().getMostRecentActiveCurricularRule(ruleType, null, executionYear);
}
public CycleCurriculumGroup getCycleCurriculumGroupFor(final CurriculumModule curriculumModule) {
for (final CycleCurriculumGroup cycleCurriculumGroup : getCycleCurriculumGroups()) {
if (cycleCurriculumGroup.hasCurriculumModule(curriculumModule)) {
return cycleCurriculumGroup;
}
}
return null;
}
public CycleCourseGroup getCycleCourseGroup(final CurriculumModule curriculumModule) {
final CycleCurriculumGroup cycleCurriculumGroup = getCycleCurriculumGroupFor(curriculumModule);
return cycleCurriculumGroup != null ? cycleCurriculumGroup.getDegreeModule() : null;
}
public CycleCourseGroup getCycleCourseGroup(final CycleType cycleType) {
return getDegreeModule().getCycleCourseGroup(cycleType);
}
public List<CycleCurriculumGroup> getInternalCycleCurriculumGroups() {
final List<CycleCurriculumGroup> result = new ArrayList<CycleCurriculumGroup>();
for (final CycleCurriculumGroup cycleCurriculumGroup : getCycleCurriculumGroups()) {
if (!cycleCurriculumGroup.isExternal()) {
result.add(cycleCurriculumGroup);
}
}
return result;
}
public List<ExternalCurriculumGroup> getExternalCycleCurriculumGroups() {
final List<ExternalCurriculumGroup> result = new ArrayList<>();
for (final CycleCurriculumGroup cycleCurriculumGroup : getCycleCurriculumGroups()) {
if (cycleCurriculumGroup.isExternal()) {
result.add((ExternalCurriculumGroup) cycleCurriculumGroup);
}
}
return result;
}
public double getDefaultEcts(final ExecutionYear executionYear) {
double result = 0d;
for (final CycleCurriculumGroup cycleCurriculumGroup : getInternalCycleCurriculumGroups()) {
result += cycleCurriculumGroup.getDefaultEcts(executionYear);
}
return result;
}
@Override
public Set<CurriculumGroup> getAllCurriculumGroups() {
Set<CurriculumGroup> result = new HashSet<CurriculumGroup>();
for (final CurriculumModule curriculumModule : getCurriculumModulesSet()) {
result.addAll(curriculumModule.getAllCurriculumGroups());
}
return result;
}
@Override
public Set<CurriculumGroup> getAllCurriculumGroupsWithoutNoCourseGroupCurriculumGroups() {
Set<CurriculumGroup> result = new HashSet<CurriculumGroup>();
for (final CurriculumModule curriculumModule : getCurriculumModulesSet()) {
result.addAll(curriculumModule.getAllCurriculumGroupsWithoutNoCourseGroupCurriculumGroups());
}
return result;
}
}