public static function retrieveOrCreateByCareerSubjectAndStudent($career_subject_id, $student_id)
{
$c = new Criteria();
$c->add(self::CAREER_SUBJECT_ID, $career_subject_id);
$c->add(self::STUDENT_ID, $student_id);
$sacs = self::doSelectOne($c);
if ($sacs == null) {
$criteria = new criteria();
$criteria->add(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, $career_subject_id);
$career_subject_school_years = CareerSubjectSchoolYearPeer::doSelect($criteria);
$opcions = array();
foreach ($career_subject_school_years as $career_subject_school_year) {
foreach ($career_subject_school_year->getChoices() as $optional_career_subject_school_year) {
$cs = CareerSubjectPeer::retrieveByCareerSubjectSchoolYearId($optional_career_subject_school_year->getChoiceCareerSubjectSchoolYearId());
$opcions[] = $cs->getId();
}
}
$criteria = new criteria();
$criteria->add(self::CAREER_SUBJECT_ID, $opcions, Criteria::IN);
$sacs = self::doSelectOne($criteria);
if ($sacs == null) {
$sacs = new StudentApprovedCareerSubject();
$sacs->setCareerSubjectId($career_subject_id);
}
}
$sacs->setStudentId($student_id);
return $sacs;
}
public static function getCourseSubjects($widget, $values)
{
$sf_user = sfContext::getInstance()->getUser();
$career_school_year = CareerSchoolYearPeer::retrieveByPK(sfContext::getInstance()->getUser()->getAttribute('career_school_year_id'));
$career = $career_school_year->getCareer();
$c = new Criteria();
$c->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
$c->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year->getId());
$c->addJoin(CourseSubjectPeer::COURSE_ID, CoursePeer::ID);
$c->add(CoursePeer::SCHOOL_YEAR_ID, SchoolYearPeer::retrieveCurrent()->getId());
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, CareerSubjectPeer::ID);
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID);
$c->add(CareerSubjectPeer::YEAR, $values);
if ($sf_user->isPreceptor()) {
$course_ids = PersonalPeer::retrieveCourseIdsjoinWithDivisionCourseOrCommission($sf_user->getGuardUser()->getId(), true);
$c->add(CoursePeer::ID, $course_ids, Criteria::IN);
$c->addJoin(CourseSubjectPeer::COURSE_ID, CoursePeer::ID);
}
$course_ids = array();
foreach (CourseSubjectPeer::doSelect($c) as $course_subject) {
if ($course_subject->hasAttendanceForSubject()) {
$course_ids[] = $course_subject->getId();
}
}
$criteria = new Criteria();
$criteria->add(CourseSubjectPeer::ID, $course_ids, Criteria::IN);
$criteria->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
CareerSubjectSchoolYearPeer::sorted($criteria);
$widget->setOption('criteria', $criteria);
}
public function createExaminationSubjectsForYear($year)
{
$career_subject_school_years = CareerSubjectSchoolYearPeer::retrieveForExaminationAndYear($this, $year);
foreach ($career_subject_school_years as $career_subject_school_year) {
$examination_subject = new ExaminationSubject();
$examination_subject->setCareerSubjectSchoolYearId($career_subject_school_year->getId());
$this->addExaminationSubject($examination_subject);
}
}
public function getExcludeRepprovedSubjects()
{
$c = new Criteria();
$c->add(CareerSubjectPeer::SUBJECT_ID, self::ED_FISICA);
$c->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$result = array();
foreach (CareerSubjectSchoolYearPeer::doSelect($c) as $career_school_year) {
$result[] = $career_school_year->getId();
}
return $result;
}
public function executeUpdateOptional(sfWebRequest $request)
{
$this->career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByPk($request->getParameter('id'));
if (null === $this->career_subject_school_year) {
$this->getUser()->setFlash('error', 'Debe seleccionar una materia para editar sus opciones');
$this->redirect('@career_school_year');
}
$this->form = new OptionalCareerSubjectManyForm($this->career_subject_school_year);
$this->processForm($request, $this->form);
$this->setTemplate('optional');
}
public function getResult($with_mark = true)
{
$career_subject = CareerSubjectSchoolYearPeer::retrieveByCareerSubject($this->getCareerSubject());
$config = $career_subject->getConfiguration();
if ($config != null && !$config->isNumericalMark()) {
$letter_mark = LetterMarkPeer::getLetterMarkByValue((int) $this->getMark());
$mark = $letter_mark->getLetter();
} else {
$mark = $this->getMark();
}
return $with_mark ? 'Aprobado ' . $mark : 'Aprobado';
}
/**
* Creates examination subjects for the given examination
*
* @param Examination $examination
* @param PropelPDO $con
*/
public function createExaminationSubjects($examination, PropelPDO $con)
{
if (!$examination->isNew()) {
return;
}
$career_subject_school_years = CareerSubjectSchoolYearPeer::retrieveForExamination($examination, $con);
foreach ($career_subject_school_years as $career_subject_school_year) {
$examination_subject = new ExaminationSubject();
$examination_subject->setCareerSubjectSchoolYearId($career_subject_school_year->getId());
$examination->addExaminationSubject($examination_subject);
}
}
public static function getCourses($widget, $values)
{
$career_school_year_id = sfContext::getInstance()->getUser()->getAttribute('career_school_year_id');
$criteria = new Criteria();
$criteria->add(CareerSubjectPeer::YEAR, $values);
$criteria->add(CareerSubjectPeer::IS_OPTION, false);
$criteria->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$criteria->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
$criteria->addJoin(CareerSubjectPeer::SUBJECT_ID, SubjectPeer::ID);
CareerSubjectSchoolYearPeer::sorted($criteria);
$widget->setOption('criteria', $criteria);
}
public function configure()
{
$sf_formatter_revisited = new sfWidgetFormSchemaFormatterRevisited($this);
$this->getWidgetSchema()->addFormFormatter('Revisited', $sf_formatter_revisited);
$this->getWidgetSchema()->setFormFormatterName('Revisited');
$this->loadHelpers(array('Tag', 'Asset'));
//WIDGETS
$this->setWidget('id', new sfWidgetFormInputHidden());
$criteria = CareerSubjectSchoolYearPeer::getAvailableChoicesCriteria($this->getObject(), $exclude_related = false, $exclude_repetead = false);
$this->setWidget('option_career_subject_list', new sfWidgetFormPropelChoice(array('model' => 'CareerSubjectSchoolYear', 'multiple' => true, 'criteria' => $criteria, 'renderer_class' => 'csWidgetFormSelectDoubleList')));
$this->getWidget('option_career_subject_list')->setLabel('Opciones');
$this->widgetSchema->setNameFormat('optional_career_subject[%s]');
//VALIDATORS
$this->setValidator('id', new sfValidatorPropelChoice(array('model' => 'CareerSubjectSchoolYear')));
$this->setValidator('option_career_subject_list', new sfValidatorPropelChoice(array('model' => 'CareerSubjectSchoolYear', 'multiple' => true, 'required' => false, 'criteria' => $criteria)));
}
public function updateOptionalCareerSubject($widget, $value)
{
$school_year_id = array_shift($value);
$criteria = new Criteria();
if ($school_year_id != "") {
$career_subject = $this->getObject()->getCareerSubject();
$school_year = SchoolYearPeer::retrieveByPK($school_year_id);
$career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($career_subject, $school_year);
$opcions = array();
foreach ($career_subject_school_year->getChoices() as $optional_career_subject_school_year) {
$cs = CareerSubjectPeer::retrieveByCareerSubjectSchoolYearId($optional_career_subject_school_year->getChoiceCareerSubjectSchoolYearId());
$opcions[] = $cs->getId();
}
//$opcions es un arreglo con todas las posibles optativas
$criteria->add(CareerSubjectPeer::ID, $opcions, Criteria::IN);
$widget->getOption('widget')->setOption('criteria', $criteria);
}
}
public function getOptionalCourseSubjectStudents($student, $school_year = null)
{
if (is_null($school_year)) {
$school_year = SchoolYearPeer::retrieveCurrent();
}
$c = new Criteria();
$c->add(CoursePeer::SCHOOL_YEAR_ID, $school_year->getId());
$c->addJoin(CourseSubjectPeer::COURSE_ID, CoursePeer::ID);
$c->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
$c->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
$c->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$c->add(CareerSubjectPeer::IS_OPTION, true);
CareerSubjectSchoolYearPeer::sorted($c);
$course_subject_students = $student->getCourseSubjectStudents($c);
$results = array();
foreach ($course_subject_students as $css) {
$results[] = $css;
}
return $results;
}
public function save($con = null)
{
if (!$this->isValid()) {
throw $this->getErrorSchema();
}
if (is_null($con)) {
$con = Propel::getConnection(CareerSubjectSchoolYearPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
}
try {
$con->beginTransaction();
$values = $this->getValues();
// TODO: ver si se puede mejorar esto:
$fields = array("final_examination_required", "course_required", "course_minimun_mark", "course_examination_count", "max_previous", "evaluation_method", "course_type", "attendance_type");
$to_save = array();
foreach ($fields as $field) {
$to_save[$field] = isset($values[$field]) ? $values[$field] : null;
unset($values[$field]);
}
foreach ($values as $career_subject_school_year_id) {
$career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByPk($career_subject_school_year_id, $con);
$subject_configuration = $career_subject_school_year->getSubjectConfigurationOrCreate();
foreach ($to_save as $field => $value) {
if (!is_null($value)) {
$method = "set" . sfInflector::camelize($field);
$subject_configuration->{$method}($value);
}
}
$career_subject_school_year->setSubjectConfiguration($subject_configuration);
$subject_configuration->setCourseMarks(BaseCustomOptionsHolder::getInstance('CourseType')->getMarksFor($subject_configuration->getCourseType()));
$subject_configuration->setEvaluationMethod(BaseCustomOptionsHolder::getInstance('CourseType')->getEvaluationMethodFor($subject_configuration->getCourseType()));
$subject_configuration->save($con);
}
$con->commit();
} catch (Exception $e) {
$con->rollBack();
throw $e;
}
return $this->object;
}
public function executeUpdateConfiguration(sfWebRequest $request)
{
$this->career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByPK($request->getParameter('id'));
if (null === $this->career_school_year) {
$this->getUser()->setFlash('error', 'Debe seleccionar una carrera para editar su configuracion');
$this->redirect('@career_school_year');
}
$subject_configuration = $this->career_subject_school_year->getSubjectConfigurationOrCreate();
$this->career_subject_school_year->setSubjectConfiguration($subject_configuration);
$parameters = $request->getPostParameters();
$parameter = $parameters["subject_configuration"];
if ($this->career_subject_school_year->hasChoices()) {
$course_subjects = array();
foreach ($this->career_subject_school_year->getChoices() as $option) {
$course_subjects = array_merge($course_subjects, CourseSubjectPeer::retrieveByCareerSubjectSchoolYear($option->getChoiceCareerSubjectSchoolYearId()));
}
} else {
$course_subjects = CourseSubjectPeer::retrieveByCareerSubjectSchoolYear($this->career_subject_school_year->getId());
}
//actualización de las notas para los cursos
$this->updateCourseMarksConfiguration($parameter, $subject_configuration, $course_subjects);
//actualización del tipo de curso para los cursos
$this->updateCourseTypeConfiguration($parameter, $subject_configuration, $course_subjects);
//actualización del tipo de asistencia para los cursos y las asistencias de los alumnos
$this->updateStudentAssistanceConfiguration($parameter, $subject_configuration, $course_subjects);
$form_name = SchoolBehaviourFactory::getInstance()->getFormFactory()->getCareerSubjectSchoolYearConfigurationForm();
$this->form = new $form_name($subject_configuration);
$this->form->bind($request->getParameter($this->form->getName()), $request->getFiles($this->form->getName()));
if ($this->form->isValid()) {
$notice = $this->getProcessFormNotice($this->form->getObject()->isNew());
$subject_configuration = $this->form->save();
$this->getUser()->setFlash('notice', $notice);
} else {
$this->setProcessFormErrorFlash();
}
$this->setTemplate('configuration');
}
public function saveSubject(PropelPDO $con)
{
if (!isset($this->widgetSchema['subject'])) {
// somebody has unset this widget
return;
}
foreach ($this->getObject()->getCourseSubjects() as $course_subject) {
$course_subject->delete($con);
}
$values = $this->getValue('subject');
if ($values) {
try {
$con->beginTransaction();
foreach ($values as $value) {
$career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByPK($value);
$career_subject_school_year->createCourseSubject($this->getObject(), $con);
}
$con->commit();
} catch (Exception $e) {
throw $e;
$con->rollBack();
}
}
}
public static function getCourses($widget, $values)
{
$career_school_year_id = sfContext::getInstance()->getUser()->getAttribute('career_school_year_id');
$c2 = new Criteria();
$c2->add(CareerSubjectPeer::YEAR, $values);
$c2->add(CareerSubjectPeer::HAS_OPTIONS, false);
$c2->addAnd(CareerSubjectPeer::IS_OPTION, false);
$c2->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$c2->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
$c2->addSelectColumn(CareerSubjectSchoolYearPeer::ID);
$stmt2 = CareerSubjectSchoolYearPeer::doSelectStmt($c2);
$no_options = $stmt2->fetchAll();
$c = new Criteria();
$c->add(CareerSubjectPeer::YEAR, $values);
$c->add(CareerSubjectPeer::HAS_OPTIONS, false);
$c->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$c->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
$c->addJoin(CareerSubjectPeer::SUBJECT_ID, SubjectPeer::ID);
$c->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$c->addJoin(OptionalCareerSubjectPeer::CHOICE_CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
$c->clearSelectColumns();
$c->addSelectColumn(CareerSubjectSchoolYearPeer::ID);
$stmt = CareerSubjectSchoolYearPeer::doSelectStmt($c);
$options = $stmt->fetchAll();
$all = array_merge($options, $no_options);
$choice = array();
foreach ($all as $echa) {
$choice[] = $echa['ID'];
}
$criteria = new Criteria();
$criteria->add(CareerSubjectSchoolYearPeer::ID, $choice, Criteria::IN);
$criteria->addJoin(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, CareerSubjectPeer::ID);
$criteria->addJoin(CareerSubjectPeer::SUBJECT_ID, SubjectPeer::ID);
$criteria->addAscendingOrderByColumn(SubjectPeer::NAME);
$widget->setOption('criteria', $criteria);
}
<tr>
<th class ="sf_admin_text"> Alumno </th>
<th class ="sf_admin_text"> Materia </th>
<th class ="sf_admin_text"> Cantidad de inscripciones </th>
</tr>
</thead>
<tbody>
<?php
foreach ($result as $student_id => $student_whith_errors) {
?>
<tr class ="sf_admin_row">
<td class ="sf_admin_text"><?php
echo StudentPeer::retrieveByPK($student_id);
?>
</td>
<td class ="sf_admin_text"><?php
echo CareerSubjectSchoolYearPeer::retrieveByPK(key($student_whith_errors));
?>
</td>
<td class ="sf_admin_text"><?php
echo $student_whith_errors[key($student_whith_errors)];
?>
</td>
</tr>
<?php
}
?>
</tbody>
</table>
</div>
public function getCareerSubjectSchoolYear()
{
return CareerSubjectSchoolYearPeer::retrieveByPK($this->getCareerSubjectSchoolYearId());
}
public function retrieveInstanceForSchoolYear($school_year)
{
$c = new Criteria();
$c->add(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, $this->getId());
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID);
$c->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, $school_year->getId());
return CareerSubjectSchoolYearPeer::doSelectOne($c);
}
/**
* Event listener function that should be registered to
* 'admin.build_criteria' event in order to add some
* personalized criteria restrictions.
*
* @param sfEvent $event
* @param Criteria $criteria
*/
static function applyRestrictions(sfEvent $event, $criteria)
{
$user = sfContext::getInstance()->getUser();
if ($event->getSubject() instanceof schoolyearActions) {
// Restrictions for schoolyear module
// $criteria->add(...);
} elseif ($event->getSubject() instanceof career_subjectActions) {
// Restrictions for careersubject module
if ($user->getReferenceFor('career')) {
$criteria->add(CareerSubjectPeer::CAREER_ID, $user->getReferenceFor('career'));
CareerSubjectPeer::OrderByYearAndName($criteria);
}
} elseif ($event->getSubject() instanceof career_subject_optionActions) {
// Restrictions for careersubject module
if ($user->getReferenceFor('career')) {
$criteria->add(CareerSubjectPeer::IS_OPTION, true);
$criteria->add(CareerSubjectPeer::CAREER_ID, $user->getReferenceFor('career'));
}
} elseif ($event->getSubject() instanceof career_school_yearActions) {
if ($school_year_id = $user->getReferenceFor('schoolyear')) {
$criteria->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, $school_year_id);
}
} elseif ($event->getSubject() instanceof career_subject_school_yearActions) {
if ($career_school_year_id = $user->getReferenceFor('career_school_year')) {
$criteria->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
$criteria->add(CareerSubjectPeer::IS_OPTION, false);
$criteria->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
CareerSubjectSchoolYearPeer::sorted($criteria);
}
} elseif ($event->getSubject() instanceof optional_school_yearActions) {
if ($career_school_year_id = $user->getReferenceFor('career_school_year')) {
$criteria->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
$criteria->add(CareerSubjectPeer::HAS_OPTIONS, true);
$criteria->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
}
} elseif ($event->getSubject() instanceof division_courseActions) {
if ($division_id = $user->getReferenceFor('division')) {
$criterion = $criteria->getNewCriterion(CoursePeer::DIVISION_ID, $division_id);
$criterion->addOr($criteria->getNewCriterion(CoursePeer::RELATED_DIVISION_ID, $division_id));
$criteria->add($criterion);
}
if ($user->isPreceptor()) {
self::addCoursePreceptorCriteria($criteria, $user);
}
if ($user->isTeacher()) {
self::addCourseTeacherCriteria($criteria, $user);
}
$criteria->setDistinct();
} elseif ($event->getSubject() instanceof divisionActions) {
DivisionPeer::sorted($criteria);
if ($user->isPreceptor()) {
self::addDivisionPreceptorCriteria($criteria, $user);
} elseif ($user->isTeacher()) {
self::addDivisionTeacherCriteria($criteria, $user);
} elseif ($user->isHeadPreceptor()) {
self::addDivisionHeadPersonalCriteria($criteria, $user);
}
} else {
if ($event->getSubject() instanceof shared_studentActions) {
$reference_array = sfContext::getInstance()->getUser()->getReferenceFor("shared_student");
$peer = $reference_array["peer"];
$fk = $reference_array["fk"];
if (isset($reference_array["object_id"])) {
$object_id = $reference_array["object_id"];
} else {
$object_ids = $reference_array["object_ids"];
}
$criteria->addJoin(constant("{$peer}::STUDENT_ID"), StudentPeer::ID);
$criteria->addGroupByColumn(StudentPeer::ID);
if (isset($object_id)) {
$criteria->add(constant("{$peer}::{$fk}"), $object_id);
} else {
$criteria->add(constant("{$peer}::{$fk}"), $object_ids, Criteria::IN);
}
$criteria->addJoin(StudentPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
} else {
if ($event->getSubject() instanceof examinationActions || $event->getSubject() instanceof manual_examinationActions) {
$school_year_id = sfContext::getInstance()->getUser()->getReferenceFor("schoolyear");
$criteria->add(ExaminationPeer::SCHOOL_YEAR_ID, $school_year_id);
if ($user->isTeacher()) {
$criteria->addJoin(ExaminationPeer::ID, ExaminationSubjectPeer::EXAMINATION_ID);
$criteria->addJoin(ExaminationSubjectPeer::ID, ExaminationSubjectTeacherPeer::EXAMINATION_SUBJECT_ID);
$criteria->addJoin(ExaminationSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} else {
if ($event->getSubject() instanceof examination_subjectActions) {
$examination_id = sfContext::getInstance()->getUser()->getReferenceFor("examination");
$criteria->add(ExaminationSubjectPeer::EXAMINATION_ID, $examination_id);
$criteria->addJoin(CareerSubjectSchoolYearPeer::ID, ExaminationSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID);
$criteria->addJoin(CareerSubjectPeer::ID, CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID);
$criteria->addAscendingOrderByColumn(CareerSubjectPeer::YEAR);
if ($user->isTeacher()) {
$criteria->addJoin(ExaminationSubjectPeer::ID, ExaminationSubjectTeacherPeer::EXAMINATION_SUBJECT_ID);
$criteria->addJoin(ExaminationSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} else {
if ($event->getSubject() instanceof manual_examination_subjectActions) {
$examination_id = sfContext::getInstance()->getUser()->getReferenceFor("manual_examination");
$criteria->add(ExaminationSubjectPeer::EXAMINATION_ID, $examination_id);
if ($user->isTeacher()) {
$criteria->addJoin(ExaminationSubjectPeer::ID, ExaminationSubjectTeacherPeer::EXAMINATION_SUBJECT_ID);
$criteria->addJoin(ExaminationSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} elseif ($event->getSubject() instanceof examination_repprovedActions) {
$school_year_id = sfContext::getInstance()->getUser()->getReferenceFor("schoolyear");
$criteria->add(ExaminationRepprovedPeer::SCHOOL_YEAR_ID, $school_year_id);
if ($user->isTeacher()) {
$criteria->addJoin(ExaminationRepprovedPeer::ID, ExaminationRepprovedSubjectPeer::EXAMINATION_REPPROVED_ID);
$criteria->addJoin(ExaminationRepprovedSubjectPeer::ID, ExaminationRepprovedSubjectTeacherPeer::EXAMINATION_REPPROVED_SUBJECT_ID);
$criteria->addJoin(ExaminationRepprovedSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} elseif ($event->getSubject() instanceof examination_repproved_subjectActions) {
$examination_repproved_id = sfContext::getInstance()->getUser()->getReferenceFor("examination_repproved");
$criteria->add(ExaminationRepprovedSubjectPeer::EXAMINATION_REPPROVED_ID, $examination_repproved_id);
ExaminationRepprovedSubjectPeer::sortedBySubject($criteria);
if ($user->isTeacher()) {
$criteria->addJoin(ExaminationRepprovedSubjectPeer::ID, ExaminationRepprovedSubjectTeacherPeer::EXAMINATION_REPPROVED_SUBJECT_ID);
$criteria->addJoin(ExaminationRepprovedSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} else {
if ($event->getSubject() instanceof courseActions) {
$school_year = SchoolYearPeer::retrieveCurrent();
$criteria->add(CoursePeer::DIVISION_ID, null, Criteria::ISNULL);
$criteria->add(CoursePeer::SCHOOL_YEAR_ID, $school_year->getId());
if ($user->isPreceptor()) {
PersonalPeer::joinWithCourse($criteria, $user->getGuardUser()->getId());
}
if ($user->isTeacher()) {
$criteria->addJoin(CoursePeer::ID, CourseSubjectPeer::COURSE_ID);
$criteria->addJoin(CourseSubjectPeer::ID, CourseSubjectTeacherPeer::COURSE_SUBJECT_ID);
$criteria->addJoin(CourseSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
$criteria->setDistinct();
}
} else {
if ($event->getSubject() instanceof commissionActions) {
/*
$school_year = SchoolYearPeer::retrieveCurrent();
$criteria->add(CoursePeer::SCHOOL_YEAR_ID, $school_year->getId());
*/
CoursePeer::sorted($criteria);
$criteria->add(CoursePeer::DIVISION_ID, null, Criteria::ISNULL);
$criteria->add(CoursePeer::IS_PATHWAY, false);
if ($user->isPreceptor()) {
PersonalPeer::joinWithCourse($criteria, $user->getGuardUser()->getId());
} elseif ($user->isTeacher()) {
TeacherPeer::joinWithCourses($criteria, $user->getGuardUser()->getId(), true);
}
if ($user->isHeadPreceptor()) {
self::addCommissionHeadPreceptorCriteria($criteria, $user);
}
} else {
if ($event->getSubject() instanceof final_examinationActions) {
$school_year_id = sfContext::getInstance()->getUser()->getReferenceFor("schoolyear");
$criteria->add(FinalExaminationPeer::SCHOOL_YEAR_ID, $school_year_id);
} else {
if ($event->getSubject() instanceof final_examination_subjectActions) {
$final_examination_id = sfContext::getInstance()->getUser()->getReferenceFor("final_examination");
$criteria->add(FinalExaminationSubjectPeer::FINAL_EXAMINATION_ID, $final_examination_id);
if ($user->isTeacher()) {
$criteria->addJoin(FinalExaminationSubjectTeacherPeer::TEACHER_ID, TeacherPeer::ID);
$criteria->addJoin(TeacherPeer::PERSON_ID, PersonPeer::ID);
$criteria->add(PersonPeer::IS_ACTIVE, true);
$criteria->add(PersonPeer::USER_ID, $user->getGuardUser()->getId());
}
} else {
if ($event->getSubject() instanceof equivalenceActions) {
$student_id = sfContext::getInstance()->getUser()->getReferenceFor("student");
$criteria->add(StudentCareerSchoolYearPeer::STUDENT_ID, $student_id);
} else {
if ($event->getSubject() instanceof sub_orientationActions) {
$orientation_id = sfContext::getInstance()->getUser()->getReferenceFor("orientation");
$criteria->add(SubOrientationPeer::ORIENTATION_ID, $orientation_id);
} else {
if ($event->getSubject() instanceof student_reincorporationActions) {
$student_id = sfContext::getInstance()->getUser()->getReferenceFor("student");
if (is_null($student_id)) {
$student_id = $user->getAttribute('student_id');
}
$criteria->add(StudentReincorporationPeer::STUDENT_ID, $student_id);
$criteria->addJoin(StudentReincorporationPeer::CAREER_SCHOOL_YEAR_PERIOD_ID, CareerSchoolYearPeriodPeer::ID);
$criteria->addJoin(CareerSchoolYearPeriodPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID);
$criteria->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, SchoolYearPeer::retrieveCurrent()->getId());
} elseif ($event->getSubject() instanceof shared_course_subjectActions) {
$teacher_id = sfContext::getInstance()->getUser()->getReferenceFor("teacher");
$criteria->addJoin(CourseSubjectPeer::ID, CourseSubjectTeacherPeer::COURSE_SUBJECT_ID);
$criteria->addJoin(CourseSubjectTeacherPeer::TEACHER_ID, $teacher_id);
$criteria->setDistinct();
} elseif ($event->getSubject() instanceof personalActions) {
$criteria->add(PersonalPeer::PERSONAL_TYPE, PersonalType::PRECEPTOR);
} elseif ($event->getSubject() instanceof head_personalActions) {
$criteria->add(PersonalPeer::PERSONAL_TYPE, PersonalType::HEAD_PRECEPTOR);
} elseif ($event->getSubject() instanceof student_officeActions) {
$criteria->add(PersonalPeer::PERSONAL_TYPE, PersonalType::STUDENTS_OFFICE);
} elseif ($event->getSubject() instanceof studentActions) {
if ($user->isPreceptor()) {
SchoolBehaviourFactory::getInstance()->joinPreceptorWithStudents($criteria, $user->getGuardUser()->getId());
} elseif ($user->isTeacher()) {
TeacherPeer::joinWithStudents($criteria, $user->getGuardUser()->getId());
}
if ($user->isHeadPreceptor()) {
$criteria->addJoin(DivisionStudentPeer::STUDENT_ID, StudentPeer::ID);
$criteria->addJoin(DivisionStudentPeer::DIVISION_ID, DivisionPeer::ID);
self::addDivisionHeadPersonalCriteria($criteria, $user);
}
} elseif ($event->getSubject() instanceof licenseActions) {
if (!is_null(sfContext::getInstance()->getUser()->getReferenceFor("teacher"))) {
$person_id = TeacherPeer::retrieveByPK(sfContext::getInstance()->getUser()->getReferenceFor("teacher"))->getPersonId();
} else {
$person_id = PersonalPeer::retrieveByPK(sfContext::getInstance()->getUser()->getReferenceFor("personal"))->getPersonId();
}
$criteria->add(LicensePeer::PERSON_ID, $person_id);
} elseif ($event->getSubject() instanceof teacherActions) {
$criteria->setDistinct();
} else {
if ($event->getSubject() instanceof career_school_year_periodActions) {
$career_school_year_id = sfContext::getInstance()->getUser()->getReferenceFor("career_school_year");
$criteria->add(CareerSchoolYearPeriodPeer::CAREER_SCHOOL_YEAR_ID, $career_school_year_id);
} else {
if ($event->getSubject() instanceof student_freeActions) {
$student_id = sfContext::getInstance()->getUser()->getReferenceFor("student");
if (is_null($student_id)) {
$student_id = $user->getAttribute('student_id');
}
$criteria->add(StudentFreePeer::STUDENT_ID, $student_id);
} else {
if ($event->getSubject() instanceof course_subject_student_examinationActions) {
$examination_subject_id = sfContext::getInstance()->getUser()->getReferenceFor("examination_subject");
$criteria->add(CourseSubjectStudentExaminationPeer::EXAMINATION_SUBJECT_ID, $examination_subject_id);
} else {
if ($event->getSubject() instanceof student_examination_repproved_subjectActions) {
$examination_repproved_subject_id = sfContext::getInstance()->getUser()->getReferenceFor("examination_repproved_subject");
$criteria->add(StudentExaminationRepprovedSubjectPeer::EXAMINATION_REPPROVED_SUBJECT_ID, $examination_repproved_subject_id);
} else {
if ($event->getSubject() instanceof pathway_commissionActions) {
$criteria->add(CoursePeer::IS_PATHWAY, true);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return $criteria;
}
public function getErrorsWithCourseSubjectsStudent($career_school_year)
{
$c = new Criteria();
$c->add(CareerSchoolYearPeer::ID, $career_school_year->getId());
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID);
$c->addJoin(CareerSubjectSchoolYearPeer::ID, CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID);
$c->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
$c->add(CourseSubjectStudentPeer::STUDENT_ID, $this->getId());
$c->clearSelectColumns();
$c->addSelectColumn(CareerSubjectSchoolYearPeer::ID);
$stmt = CareerSubjectSchoolYearPeer::doSelectStmt($c);
//me quedo solo con los IDs de los CareerSubjectSchoolYear
$array = $stmt->fetchAll(PDO::FETCH_COLUMN);
unset($stmt);
//ordeno de mayot a menor
arsort($array);
//armo un arreglo con las claves de los CareerSubjectSchoolYear->ID y
//valor la cantidad de veces que esta adentro del arreglo
$array_count = array_count_values($array);
unset($array);
//Filtro los valores que son menores a 1
$array_filtered = array_filter($array_count, create_function('$each', 'return $each>1;'));
CareerSubjectSchoolYearPeer::clearInstancePool();
unset($array_count);
if (!empty($array_filtered)) {
$array_filtered = SchoolBehaviourFactory::getEvaluatorInstance()->evaluateErrorsWithCareerSubjectSchoolYear($array_filtered);
}
return $array_filtered;
}
public function copyConfiguration(PropelPDP $con = null)
{
$con = is_null($con) ? Propel::getConnection() : $con;
$c = new Criteria();
$c->add(CareerSchoolYearPeer::CAREER_ID, $this->getCareerId());
$c->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, SchoolYearPeer::retrieveCurrent()->getId(), Criteria::NOT_EQUAL);
$c->addDescendingOrderByColumn(CareerSchoolYearPeer::ID);
try {
$con->beginTransaction();
//First copy the career configuration.
$last_career = CareerSchoolYearPeer::doSelectOne($c);
$configuration = $last_career->getSubjectConfiguration()->copy();
$this->setSubjectConfiguration($configuration);
//Second copy the career_subjects configurations
foreach ($this->getCareerSubjectSchoolYears() as $cssy) {
$c = new Criteria();
$c->add(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, $cssy->getCareerSubjectId());
$c->add(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $last_career->getId());
$last_career_subject = CareerSubjectSchoolYearPeer::doSelectOne($c);
if (!is_null($last_career_subject) && !is_null($last_career_subject->getSubjectConfiguration())) {
$cssy->setSubjectConfiguration($last_career_subject->getSubjectConfiguration()->copy());
$cssy->save($con);
}
}
$this->save($con);
$con->commit();
} catch (PropelException $e) {
$con->rollback();
throw $e->getMessage();
}
}
public static function retrieveByStudentApprovedCareerSubject($student_approved_career_subject, $school_year = null)
{
$career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($student_approved_career_subject->getCareerSubject(), $school_year);
return self::retrieveByCareerSubjectSchoolYearAndStudent($career_subject_school_year, $student_approved_career_subject->getStudentId());
}
public function createAllCourses($con = null)
{
if (is_null($con)) {
$con = Propel::getConnection();
}
try {
$con->beginTransaction();
/* @var $career_subject CareerSubject */
foreach ($this->getUnrelatedCareerSubjects() as $career_subject) {
$career_subject_school_year_id = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($career_subject, $this->getSchoolYear())->getId();
$this->createCourse($career_subject_school_year_id, $con);
}
$con->commit();
} catch (PropelException $e) {
}
}
public function getLastYearCareerSubjectSchoolYear()
{
$last_school_year = SchoolYearPeer::retrieveLastYearSchoolYear($this->getSchoolYear());
$last_year_career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($this->getCareerSubject(), $last_school_year);
return $last_year_career_subject_school_year;
}
public function addSubjectColumnCriteria(Criteria $criteria, $field, $value)
{
$current_career_subject_school_year_ids = CareerSubjectSchoolYearPeer::getCurrentCareerSubjectSchoolYearIdsBySubjectId($value);
$criteria->add(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, $current_career_subject_school_year_ids, Criteria::IN);
$criteria->addJoin(CourseSubjectTeacherPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
$criteria->addJoin(TeacherPeer::ID, CourseSubjectTeacherPeer::TEACHER_ID);
}
public function getCourseSubjectStudentsForCourseType($student, $course_type, $school_year = null)
{
$not_in = SchoolBehaviourFactory::getEvaluatorInstance()->getLvmSpecialSubjectIds($school_year);
if (is_null($school_year)) {
$school_year = SchoolYearPeer::retrieveCurrent();
}
$c = new Criteria();
$c->add(CoursePeer::SCHOOL_YEAR_ID, $school_year->getId());
$c->addJoin(CourseSubjectPeer::COURSE_ID, CoursePeer::ID);
$c->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
$c->add(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, $not_in, Criteria::NOT_IN);
$c->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
CareerSubjectSchoolYearPeer::sorted($c);
$course_subject_students = $student->getCourseSubjectStudents($c);
$results = array();
foreach ($course_subject_students as $css) {
if ($css->getCourseSubject()->getCourseType() == $course_type) {
$results[] = $css;
}
}
return $results;
}
public function getLvmSpecialSubjects($school_year = null)
{
if (is_null($school_year)) {
$school_year = SchoolYearPeer::retrieveCurrent();
}
$c = new Criteria();
$c->add(CareerSubjectPeer::SUBJECT_ID, $this->_introduccion, Criteria::IN);
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, CareerSubjectPeer::ID);
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID, Criteria::INNER_JOIN);
$c->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, $school_year->getId());
return CareerSubjectSchoolYearPeer::doSelect($c);
}
public function copyCourseSubjects(PropelPDO $con = null, Division $division = null, CareerSchoolYear $career_school_year, $copy_course)
{
$course_subjects = $this->getCourseSubjects();
foreach ($course_subjects as $course_subject) {
$copy_course_subject = new CourseSubject();
$copy_course_subject->setCourse($copy_course);
$career_subject_school_year = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($course_subject->getCareerSubjectSchoolYear()->getCareerSubject(), $career_school_year->getSchoolYear());
CareerSubjectSchoolYearPeer::clearInstancePool();
$copy_course_subject->setCareerSubjectSchoolYear($career_subject_school_year);
$copy_course_subject->save($con);
$course_subject->copyTeachersToCourseSubject($con, $copy_course_subject);
$course_subject->copyCourseSubjectDays($con, $copy_course_subject);
$career_subject_school_year->clearAllReferences(true);
unset($career_subject_school_year);
$copy_course_subject->clearAllReferences(true);
unset($copy_course_subject);
$course_subject->clearAllReferences(true);
unset($course_subject);
}
unset($course_subjects);
$this->clearAllReferences(true);
}
public function getHistoriaDelArteForSchoolYear($school_year)
{
$c = new Criteria();
$c->add(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, 134);
$c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID, Criteria::INNER_JOIN);
$c->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, $school_year->getId());
return CareerSubjectSchoolYearPeer::doSelectOne($c);
}
public static function retrieveByCareerSubjectSchoolYearId($career_subject_school_year_id)
{
return CareerSubjectSchoolYearPeer::retrieveByPK($career_subject_school_year_id)->getCareerSubject();
}
