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;
 }
Exemple #2
0
 public function executeUpdateCorrelatives(sfWebRequest $request)
 {
     $this->career_subject = CareerSubjectPeer::retrieveByPK($request->getParameter('id'));
     if (null === $this->career_subject) {
         $this->getUser()->setFlash('error', 'Debe seleccionar una materia para editar sus correlativas');
         $this->redirect('@career_subject');
     }
     $correlative = new Correlative();
     $correlative->setCareerSubjectId($this->career_subject->getId());
     $this->form = new CorrelativeForm($correlative);
     $this->processForm($request, $this->form);
     $this->setTemplate('editCorrelatives');
 }
 public function configure()
 {
     $sf_formatter_revisited = new sfWidgetFormSchemaFormatterRevisited($this);
     $this->getWidgetSchema()->addFormFormatter('Revisited', $sf_formatter_revisited);
     $this->getWidgetSchema()->setFormFormatterName('Revisited');
     unset($this['created_at']);
     /* Career subject to which we are assigning correlatives */
     $this->setWidget('career_subject_id', new sfWidgetFormReadOnly(array('plain' => false, 'value_callback' => array('CareerSubjectPeer', 'retrieveByPk'))));
     $this->widgetSchema->setLabel('career_subject_id', 'Materia');
     /* Career subjects available to select as correlatives */
     $this->setWidget('correlative_career_subject_id', new sfWidgetFormPropelChoice(array('model' => 'CareerSubject', 'multiple' => true, 'criteria' => CareerSubjectPeer::getAvailableCarrerSubjectsAsCorrelativesCriteriaFor($this->getObject()->getCareerSubjectRelatedByCareerSubjectId()), 'renderer_class' => 'csWidgetFormSelectDoubleList')));
     $this->setValidator('correlative_career_subject_id', new sfValidatorPropelChoice(array('model' => 'CareerSubject', 'multiple' => true, 'criteria' => CareerSubjectPeer::getAvailableCarrerSubjectsAsCorrelativesCriteriaFor($this->getObject()->getCareerSubjectRelatedByCareerSubjectId()), 'required' => false)));
     $this->widgetSchema->setLabel('correlative_career_subject_id', 'Correlativas');
 }
 protected function doSave($con = null)
 {
     $values = $this->getValues();
     $optional_career_subject = new CareerSubject();
     $optional_career_subject->setSubjectId($values['subject_id']);
     $optional_career_subject->setIsOption(true);
     $career_subject = CareerSubjectPeer::retrieveByPK($values['career_subject_id']);
     $optional_career_subject->setCareerId($career_subject->getCareerId());
     $optional_career_subject->setYear($career_subject->getYear());
     $optional_career_subject->setSubjectConfigurationId($career_subject->getSubjectConfigurationId());
     $optional_career_subject->setCreditHours($career_subject->getCreditHours());
     $this->getObject()->setCareerSubjectRelatedByOptionalCareerSubjectId($optional_career_subject);
     parent::doSave($con);
     $career_subject->setHasOptions(true);
     $career_subject->save($con);
 }
Exemple #5
0
 public function executeUpdateEquivalence(sfWebRequest $request)
 {
     $parametrs = $request->getPostParameters();
     $this->career_school_year = CareerSchoolYearPeer::retrieveByPK($parametrs['career_school_year_id']);
     $this->career = $this->career_school_year->getCareer();
     $this->career_subject_school_years = array();
     $this->years = array();
     $this->forms = array();
     for ($y = 1; $y <= $this->career->getQuantityYears(); $y++) {
         $this->years[] = $y;
         $this->career_subject_school_years[$y] = $this->career->getCareerSubjectsForYear($y, true);
     }
     unset($parametrs['_save']);
     unset($parametrs['career_school_year_id']);
     $valid = true;
     foreach ($parametrs as $parameter) {
         $career_subject_id = $parameter['career_subject_id'];
         $student_id = $parameter['student_id'];
         $school_year_id = $parameter['school_year'];
         $career_subject = CareerSubjectPeer::retrieveByPK($career_subject_id);
         $student = StudentPeer::retrieveByPK($student_id);
         $student_approved_career_subject = StudentApprovedCareerSubjectPeer::retrieveOrCreateByCareerSubjectAndStudent($career_subject->getId(), $student->getId());
         $student_approved_career_subject->setSchoolYearId($school_year_id);
         $parameter['career_subject_id'] = $student_approved_career_subject->getCareerSubjectId();
         $this->form = new EquivalenceForm($student_approved_career_subject);
         $this->form->setCareerSubjectAndStudent($career_subject, $student);
         if (isset($parameter['mark']) && $parameter['mark'] != "") {
             $this->form->bind($parameter);
             if ($this->form->isValid()) {
                 $this->form->save();
             } else {
                 $valid = false;
             }
         }
         $this->form = new EquivalenceForm($student_approved_career_subject);
         $this->form->setCareerSubjectAndStudent($career_subject, $student);
         $this->forms[$career_subject->getId()] = $this->form;
         $parameter['career_subject_id'] = $career_subject_id;
     }
     if ($valid) {
         $this->getUser()->setFlash('notice', 'subjects are updated correctly');
     } else {
         $this->setProcessFormErrorFlash();
     }
     $this->module = $this->getModuleName();
     $this->setTemplate('makeUpEquivalence');
 }
 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);
     }
 }
 protected function execute($arguments = array(), $options = array())
 {
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $connection = $databaseManager->getDatabase($options['connection'] ? $options['connection'] : null)->getConnection();
     $this->createContextInstance('backend');
     $c = new Criteria();
     //$c->add(CareerStudentPeer::STUDENT_ID, 1080);
     $school_year = SchoolYearPeer::retrieveCurrent();
     try {
         $connection->beginTransaction();
         foreach (CareerStudentPeer::doSelect($c) as $career_student) {
             $student = $career_student->getStudent();
             $career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($career_student->getCareer(), $school_year);
             $student_career_school_year = StudentCareerSchoolYearPeer::getCurrentForStudentAndCareerSchoolYear($student, $career_school_year);
             if (is_null($student_career_school_year)) {
                 $this->logSection("Continue", '1');
                 continue;
             }
             $year = $student_career_school_year->getYear();
             $c = new Criteria();
             $c->add(CareerSubjectPeer::CAREER_ID, $career_student->getCareerId());
             $c->add(CareerSubjectPeer::YEAR, $year);
             foreach (CareerSubjectPeer::doSelect($c) as $career_subject) {
                 if (StudentCareerSubjectAllowedPeer::doCountStudentAndCareerSubject($student, $career_subject) == 0) {
                     $obj = new StudentCareerSubjectAllowed();
                     $obj->setStudentId($student->getId());
                     $obj->setCareerSubject($career_subject);
                     $obj->save($connection);
                     $this->logSection("Allowed agregado: ", $career_subject->getId());
                 }
             }
         }
         $connection->commit();
     } catch (PropelException $e) {
         $connection->rollback();
         throw $e;
     }
 }
 public function configure()
 {
     unset($this['is_closed']);
     $this->setWidget("examination_repproved_id", new sfWidgetFormInputHidden());
     $examination_repproved = $this->getObject()->getExaminationRepproved();
     if ($this->getObject()->isNew()) {
         $criteria = CareerSubjectPeer::retrieveForExaminationRepprovedCriteria($examination_repproved);
         $this->getWidget('career_subject_id')->setOption('criteria', $criteria);
         $this->getValidator('career_subject_id')->setOption('criteria', $criteria);
         $this->getWidget('career_subject_id')->setLabel('Subject');
     } else {
         //Si es en edicion solo muestro la info, no se puede modificar la materia.
         unset($this['career_subject_id']);
         $this->setWidget('career_subject_wrapper', new mtWidgetFormWrapper(array('content' => $this->getObject()->getCareerSubject())));
         $this->setValidator('career_subject_wrapper', new sfValidatorPass());
         $this->getWidgetSchema()->moveField('career_subject_wrapper', 'before', 'examination_repproved_subject_teacher_list');
         $this->getWidget('career_subject_wrapper')->setLabel('Subject');
     }
     $this->getWidget("examination_repproved_subject_teacher_list")->setOption("multiple", true);
     $this->getWidget("examination_repproved_subject_teacher_list")->setOption("peer_method", 'doSelectActive');
     $this->getWidget("examination_repproved_subject_teacher_list")->setOption("renderer_class", "csWidgetFormSelectDoubleList");
 }
 /**
  * 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;
 }
Exemple #10
0
 /**
  * Este metodo retorna las posibes careerSubjects que el estudiante aprobo en el final.
  * Esto es por el caso de que un estudiante de un final de una materia que tiene en dos carreras.
  *
  * @param FinalExaminationSubject $final_examination_subject
  * @return array CareerSubject[]
  */
 public function getCareerSubjectForFinalExaminationSubject(FinalExaminationSubject $final_examination_subject)
 {
     $c = new Criteria();
     $c->add(CourseSubjectStudentPeer::STUDENT_ID, $this->getId());
     $c->add(CourseSubjectStudentPeer::STUDENT_APPROVED_COURSE_SUBJECT_ID, null, Criteria::ISNOTNULL);
     $c->addJoin(CourseSubjectPeer::ID, CourseSubjectStudentPeer::COURSE_SUBJECT_ID);
     $c->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
     $c->addJoin(CareerSubjectSchoolYearPeer::CAREER_SUBJECT_ID, CareerSubjectPeer::ID);
     $c->addJoin(CareerSubjectPeer::SUBJECT_ID, $final_examination_subject->getSubjectId());
     return CareerSubjectPeer::doSelectOne($c);
 }
Exemple #11
0
 public function canBeDeleted()
 {
     $c = new Criteria();
     $c->add(CareerSubjectPeer::ORIENTATION_ID, $this->getId());
     return CareerSubjectPeer::doCount($c) == 0;
 }
Exemple #12
0
 public function createStudentsCareerSubjectAllowedPathways($start_year = null, PropelPDO $con = null)
 {
     if (is_null($start_year)) {
         $start_year = CareerSubjectPeer::FIRST_YEAR;
     }
     if ($con == null) {
         $con = Propel::getConnection(StudentPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     }
     try {
         $con->beginTransaction();
         $c = new Criteria();
         $c->add(CareerSubjectPeer::YEAR, $start_year);
         //This criterion checks if the careerSubject has orientation, if has an orientation then filters for studentCareer orientation.
         $criterion = $c->getNewCriterion(CareerSubjectPeer::ORIENTATION_ID, null, Criteria::ISNULL);
         $criterion->addOr($c->getNewCriterion(CareerSubjectPeer::ORIENTATION_ID, $this->getOrientationId()));
         $c->add($criterion);
         $career_subjects = $this->getCareer()->getCareerSubjects($c, $con);
         CareerSubjectPeer::clearInstancePool();
         unset($c);
         foreach ($career_subjects as $career_subject) {
             if (!$this->isApprovedCareerSubject($career_subject, $this->getStudent())) {
                 $student_career_subject_allowed_pathway = new StudentCareerSubjectAllowedPathway();
                 $student_career_subject_allowed_pathway->setStudent($this->getStudent($con));
                 $student_career_subject_allowed_pathway->setCareerSubject($career_subject);
                 $student_career_subject_allowed_pathway->save($con);
                 unset($student_career_subject_allowed_pathway);
             }
         }
         $con->commit();
     } catch (PropelException $e) {
         $con->rollBack();
         throw $e;
     }
 }
 /**
  * This method returns a Criteria with the career_subjects that can be passed by equivalence of the student.
  *
  * @param integer $career_id
  * @param Student $student
  *
  * @return Criteria $c
  */
 public function getCareerSubjectsForEquivalenceCriteria($career_id, Student $student)
 {
     $c = new Criteria();
     //Quito las materias ya approbadas por el estudiante
     $c->add(StudentApprovedCareerSubjectPeer::STUDENT_ID, $student->getId());
     $c->clearSelectColumns();
     $c->addSelectColumn(StudentApprovedCareerSubjectPeer::CAREER_SUBJECT_ID);
     $pdo = StudentApprovedCareerSubjectPeer::doSelectStmt($c);
     $already_approved_ids = $pdo->fetchAll(PDO::FETCH_COLUMN);
     //Ahora chequeo que materias puede rendir.
     $c = new Criteria();
     $c->add(CareerSubjectPeer::CAREER_ID, $career_id);
     $c->add(CareerSubjectPeer::ID, $already_approved_ids, Criteria::NOT_IN);
     $career_subjects = CareerSubjectPeer::doSelect($c);
     $career_subject_available = array();
     foreach ($career_subjects as $career_subject) {
         if ($this->canAddEquivalenceFor($career_subject, $student)) {
             $career_subject_available[] = $career_subject->getId();
         }
     }
     $c = new Criteria();
     $c->add(CareerSubjectPeer::CAREER_ID, $career_id);
     $c->add(CareerSubjectPeer::ID, $career_subject_available, Criteria::IN);
     return $c;
 }
Exemple #14
0
 /**
  * This method returns an array of the CareerSubjects that arent associated with a course of this division.
  * In the specific case of an optative careersubject, check if the choices arent been already added.
  *
  * @return <array>  CareerSubject[]
  */
 public function getUnrelatedCareerSubjects()
 {
     $career_subject_ids = array_map(create_function('$o', 'return $o->getId();'), $this->getCareerSubjects());
     $c = new Criteria();
     $c->add(CareerSubjectPeer::CAREER_ID, $this->getCareerSchoolYear()->getCareerId());
     $c->add(CareerSubjectPeer::YEAR, $this->getYear());
     $c->add(CareerSubjectPeer::IS_OPTION, false);
     $c->add(CareerSubjectPeer::ID, $career_subject_ids, Criteria::NOT_IN);
     // Recorremos las careerSubject que no estan agregadas ya a un curso de la division
     $unrelated = array();
     foreach (CareerSubjectPeer::doSelect($c) as $cs) {
         //Si tiene opciones, entonces chequamos que no esten agregadas las opciones.
         if ($cs->getHasChoices()) {
             $csy = CareerSubjectSchoolYearPeer::retrieveByCareerSubjectAndSchoolYear($cs, $this->getSchoolYear());
             $career_subject_school_year_ids = array_map(create_function('$o', 'return $o->getChoiceCareerSubjectSchoolYearId();'), $csy->getChoices());
             $c = new Criteria();
             $c->add(CoursePeer::DIVISION_ID, $this->getId());
             $c->addJoin(CourseSubjectPeer::COURSE_ID, CoursePeer::ID);
             $c->add(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, $career_subject_school_year_ids, Criteria::IN);
             if (CourseSubjectPeer::doCount($c) == 0) {
                 $unrelated[] = $cs;
             }
         } else {
             $unrelated[] = $cs;
         }
     }
     return $unrelated;
 }
Exemple #15
0
 public function executeCreateCourse($request)
 {
     $career_subject = CareerSubjectPeer::retrieveByPk($request->getParameter('id'));
     $this->division->createCourse($career_subject->retrieveInstanceForSchoolYear($this->division->getSchoolYear())->getId());
     $this->redirect('@division_course');
 }
Exemple #16
0
 /**
  * This function returns an array of career subject objects that are in $year
  *
  * @param  int   $year Represents a school year
  *
  * @return array Career subject objects
  */
 public function getCareerSubjectForYear($year, $exclude_option = false)
 {
     $c = new Criteria();
     CareerSubjectPeer::sorted($c);
     $c->add(CareerSubjectPeer::YEAR, $year);
     if ($exclude_option) {
         $c->add(CareerSubjectPeer::IS_OPTION, false);
     }
     return $this->getCareerSubjectSchoolYearsJoinCareerSubject($c);
 }
 protected function doSave($con = null)
 {
     if (!$this->isValid()) {
         throw $this->getErrorSchema();
     }
     if (is_null($con)) {
         $con = $this->getConnection();
     }
     // Delete only the subjects off the selected career
     $c = new Criteria();
     $c->add(StudentCareerSubjectAllowedPeer::STUDENT_ID, $this->object->getPrimaryKey());
     // added:
     $subc = new Criteria();
     $subc->clearSelectColumns();
     $subc->addSelectColumn(CareerSubjectPeer::ID);
     $subc->add(CareerSubjectPeer::CAREER_ID, $this->getValue("career_id"));
     $stmt = CareerSubjectPeer::doSelectStmt($subc);
     $ids = $stmt->fetchAll(PDO::FETCH_COLUMN);
     $c->add(StudentCareerSubjectAllowedPeer::CAREER_SUBJECT_ID, $ids, Criteria::IN);
     $allowed = StudentCareerSubjectAllowedPeer::doSelectOne($c, $con);
     if ($allowed) {
         // Se consulta si el alumno esta en trayectorias antes de eliminarlo
         $student_id = $this->object->getPrimaryKey();
         $criteria = new Criteria();
         $criteria->add(PathwayStudentPeer::STUDENT_ID, $student_id);
         $pathway = PathwayStudentPeer::doSelectOne($criteria, $con);
         if (!$pathway) {
             StudentCareerSubjectAllowedPeer::doDelete($c, $con);
         }
     }
     $year = $this->getValue('year');
     $career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear(CareerPeer::retrieveByPK($this->getValue('career_id')), SchoolYearPeer::retrieveCurrent());
     //First update the year at student_career_school_year
     //    var_dump($career_school_year);die();
     $student_career_school_year = StudentCareerSchoolYearPeer::getCurrentForStudentAndCareerSchoolYear($this->getObject(), $career_school_year);
     //    if (!$student_career_school_year)
     //    {
     //      $student_career_school_year = new StudentCareerSchoolYear();
     //      $student_career_school_year->setCareerSchoolYear($career_school_year);
     //      $student_career_school_year->setStudent($this->getObject());
     //      $student_career_school_year->save();
     //    }
     $career_student = CareerStudentPeer::retrieveByCareerAndStudent($this->getValue('career_id'), $this->getObject()->getId());
     try {
         $con->beginTransaction();
         $student_career_school_year->setYear($year);
         $student_career_school_year->save($con);
         $c = new Criteria();
         $c->add(CareerSubjectPeer::CAREER_ID, $this->getValue('career_id'));
         $c->add(CareerSubjectPeer::YEAR, $year);
         foreach (CareerSubjectPeer::doSelect($c) as $career_subject) {
             $obj = new StudentCareerSubjectAllowed();
             $obj->setStudentId($this->object->getPrimaryKey());
             $obj->setCareerSubject($career_subject);
             $obj->save($con);
         }
         $prev_school_year = SchoolYearPeer::retrieveLastYearSchoolYear($career_school_year->getSchoolYear());
         if ($prev_school_year) {
             $prev_student_career_school_year = StudentCareerSchoolYearPeer::retrieveCareerSchoolYearForStudentAndYear($this->getObject(), $prev_school_year);
         }
         if (!empty($prev_student_career_school_year)) {
             $prev_student_career_school_year = array_shift($prev_student_career_school_year);
             if ($year <= $prev_student_career_school_year->getYear()) {
                 $prev_student_career_school_year->setStatus(StudentCareerSchoolYearStatus::REPPROVED);
                 $prev_student_career_school_year->save($con);
             }
         }
         $con->commit();
     } catch (PropelException $e) {
         $con->rollBack();
         throw $e;
     }
 }