public function executeStudyYear()
 {
     $this->career = $this->getVar('career');
     $this->year = $this->getVar('year');
     $this->school_year = $this->getVar('school_year');
     if (is_null($this->school_year)) {
         $this->career_subjects = $this->career->getCareerSubjectsForYear($this->year, true);
     } else {
         $career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($this->career, $this->school_year);
         $this->career_subjects = $career_school_year->getCareerSubjectForYear($this->year, true);
     }
 }
 /**
  * Creates career_subject_school_year if the career has already have an instance of career_school_year of the actual school year.
  *
  * @param CareerSubject $career_subject
  * @param PropelPDO $con
  */
 public function updateCareerSubjectSchoolYear(CareerSubject $career_subject, PropelPDO $con)
 {
     if ($career_subject->isNew()) {
         $school_year = SchoolYearPeer::retrieveCurrent();
         $career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($career_subject->getCareer(), $school_year);
         if (!is_null($career_school_year) && !$career_school_year->getIsProcessed()) {
             $career_subject_school_year = new CareerSubjectSchoolYear();
             $career_subject_school_year->setCareerSubjectId($career_subject->getId());
             $career_subject_school_year->setCareerSchoolYearId($career_school_year->getId());
             $career_subject_school_year->save($con);
         }
     }
 }
 protected function execute($arguments = array(), $options = array())
 {
     // initialize the database connection
     $databaseManager = new sfDatabaseManager($this->configuration);
     $con = $databaseManager->getDatabase($options['connection'] ? $options['connection'] : null)->getConnection();
     $this->createContextInstance('backend');
     $c = new Criteria();
     $student_career_school_years = StudentCareerSchoolYearPeer::doSelect($c);
     try {
         $school_year = SchoolYearPeer::retrieveByPk(3);
         foreach ($student_career_school_years as $student_career_school_year) {
             $year = $student_career_school_year->getYear();
             $c = new Criteria();
             $c->add(StudentCareerSubjectAllowedPeer::STUDENT_ID, $student_career_school_year->getStudentId());
             StudentCareerSubjectAllowedPeer::doDelete($c);
             if ($year < 7) {
                 $year++;
                 if ($year == 1 || $year == 4) {
                     $career = CareerPeer::retrieveByPk(8);
                 } else {
                     $career = CareerPeer::retrieveByPk(4);
                 }
                 $career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($career, $school_year);
                 $c = new Criteria();
                 $c->add(CareerStudentPeer::STUDENT_ID, $student_career_school_year->getStudentId());
                 $career_student = CareerStudentPeer::doSelectOne($c);
                 $career_student->setCareer($career);
                 $career_student->setFileNumber($career_student->getFileNumber() + rand());
                 $career_student->save($con);
                 $career_student->createStudentsCareerSubjectAlloweds($year, $con);
                 $new_student_career_school_year = new StudentCareerSchoolYear();
                 $new_student_career_school_year->setStudent($student_career_school_year->getStudent());
                 $new_student_career_school_year->setCareerSchoolYear($career_school_year);
                 $new_student_career_school_year->setYear($year);
                 $new_student_career_school_year->save($con);
             } else {
                 $student_career_school_year->delete($con);
             }
         }
     } catch (PropelException $e) {
         $con->rollback();
         throw $e;
     }
     // add your code here
 }
 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;
     }
 }
 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();
     $username = '******';
     $user = sfContext::getInstance()->getUser();
     $sf_user = sfGuardUserPeer::retrieveByUsername($username);
     $user->signin($sf_user, false);
     $new_career_school_year_2014 = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear(CareerPeer::retrieveByPK(8), SchoolYearPeer::retrieveCurrent());
     $old_career_school_year_2013 = CareerSchoolYearPeer::retrieveByPk(21);
     $new_career_school_year_2013 = CareerSchoolYearPeer::retrieveByPk(22);
     $old_career_school_year_2014 = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear(CareerPeer::retrieveByPK(4), SchoolYearPeer::retrieveCurrent());
     $last_year_school_year = SchoolYearPeer::retrieveLastYearSchoolYear(SchoolYearPeer::retrieveCurrent());
     // ---------------------------------------------------------------------------------------------- //
     // Alumnos que promueven 6to deben seguir en el plan viejo
     $this->log('1 -Alumnos que promueven 6to deben seguir en el plan viejo');
     $c = new Criteria();
     $c->add(StudentCareerSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $old_career_school_year_2013->getId());
     $c->add(StudentCareerSchoolYearPeer::IS_PROCESSED, true);
     $c->add(StudentCareerSchoolYearPeer::YEAR, 6);
     $c->add(StudentCareerSchoolYearPeer::STATUS, StudentCareerSchoolYearStatus::APPROVED);
     $students_to_old_career_school_years = StudentCareerSchoolYearPeer::doSelect($c);
     try {
         $connection->beginTransaction();
         foreach ($students_to_old_career_school_years as $socsy) {
             $shift = $socsy->getStudent()->getShiftForSchoolYear($last_year_school_year);
             if (!$socsy->getStudent()->getIsRegistered($old_career_school_year_2014->getSchoolYear())) {
                 $socsy->getStudent()->registerToSchoolYear($old_career_school_year_2014->getSchoolYear(), $shift, $connection);
             }
         }
         $connection->commit();
     } catch (PropelException $e) {
         $connection->rollBack();
         throw $e;
     }
     // ---------------------------------------------------------------------------------------------- //
     // 2 - Resto de los alumnos que no son del CBFE van al plan nuevo en el año que les corresponda
     $this->log('2 - Resto de los alumnos que no son del CBFE van al plan nuevo en el año que les corresponda');
     try {
         $connection->beginTransaction();
         // con este criteria voy a excluir a los que aprueban 6to y deben ir a 7mo del plan viejo
         $c = new Criteria();
         $c->add(StudentCareerSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, $old_career_school_year_2013->getId());
         $c->add(StudentCareerSchoolYearPeer::IS_PROCESSED, true);
         $c->add(StudentCareerSchoolYearPeer::YEAR, 6);
         $c->add(StudentCareerSchoolYearPeer::STATUS, StudentCareerSchoolYearStatus::APPROVED);
         $c->clearSelectColumns();
         $c->addSelectColumn(StudentCareerSchoolYearPeer::STUDENT_ID);
         $stmt = StudentCareerSchoolYearPeer::doSelectStmt($c);
         $students_to_old_career_school_years_ids = $stmt->fetchAll(PDO::FETCH_COLUMN);
         // con este criteria voy a excluir a los que son del CBFE
         $c = new Criteria();
         $c->add(StudentCareerSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, 23);
         $c->add(StudentCareerSchoolYearPeer::IS_PROCESSED, true);
         $c->clearSelectColumns();
         $c->addSelectColumn(StudentCareerSchoolYearPeer::STUDENT_ID);
         $stmt = StudentCareerSchoolYearPeer::doSelectStmt($c);
         $student_cbfe_ids = $stmt->fetchAll(PDO::FETCH_COLUMN);
         // al total le saco $students_to_old_career_school_years_ids y los
         // student_cbfe_ids
         $c = new Criteria();
         //$c = StudentCareerSchoolYearPeer::retrieveLastYearStudentNotGraduatedCriteria($new_career_school_year_2014);
         $c->add(StudentCareerSchoolYearPeer::YEAR, 7, Criteria::NOT_EQUAL);
         $c->addJoin(StudentCareerSchoolYearPeer::STUDENT_ID, StudentPeer::ID, Criteria::INNER_JOIN);
         $c->add(StudentPeer::ID, array_merge($students_to_old_career_school_years_ids, $student_cbfe_ids), Criteria::NOT_IN);
         $students = StudentPeer::doSelectActive($c);
         foreach ($students as $student) {
             $shift = $student->getShiftForSchoolYear($last_year_school_year);
             if (!$student->getIsRegistered($new_career_school_year_2014->getSchoolYear()) && $shift) {
                 $slcsy = $student->getLastStudentCareerSchoolYear();
                 $slcs = $student->getLastCareerStudent();
                 if ($slcsy->getStatus() == StudentCareerSchoolYearStatus::APPROVED) {
                     $start_year = $slcsy->getYear() + 1;
                 } else {
                     $start_year = $slcsy->getYear();
                 }
                 if ($slcs->getCareerId() != $new_career_school_year_2014->getCareerId()) {
                     $student->registerToCareer($new_career_school_year_2014->getCareer(), null, null, $start_year, $connection);
                     $sys = new SchoolYearStudent();
                     $sys->setStudentId($student->getId());
                     $sys->setSchoolYearId($new_career_school_year_2014->getSchoolYear()->getId());
                     $sys->setShift($shift);
                     $sys->save($connection);
                     $this->verify($student, $new_career_school_year_2014, $connection);
                 } else {
                     $sys = new SchoolYearStudent();
                     $sys->setStudentId($student->getId());
                     $sys->setSchoolYearId($new_career_school_year_2014->getSchoolYear()->getId());
                     $sys->setShift($shift);
                     $sys->save($connection);
                     $this->verify($student, $new_career_school_year_2014, $connection);
                 }
                 if (!is_null($shift)) {
                     $shift->clearAllReferences(true);
                 }
                 $student->clearAllReferences(true);
                 unset($student);
                 unset($shift);
             }
             StudentPeer::clearInstancePool();
             unset($students);
         }
         $connection->commit();
     } catch (PropelException $e) {
         $connection->rollBack();
         throw $e;
     }
 }
 public function getCareerSchoolYear()
 {
     return CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($this->getCareerSubject()->getCareer(), $this->getSchoolYear());
 }
Exemple #7
0
 public function createOrCopyLastYearSubjectConfiguration($career, PropelPDO $con = null)
 {
     $last_school_year = SchoolYearPeer::retrieveLastYearSchoolYear($this);
     $last_year_career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($career, $last_school_year);
     if (is_null($last_year_career_school_year)) {
         $subject_configuration = new SubjectConfiguration();
     } else {
         $subject_configuration = $last_year_career_school_year->getSubjectConfiguration()->copy();
     }
     $subject_configuration->save($con);
     return $subject_configuration;
 }
 public function createLastYearCommissions()
 {
     $last_year_school_year = SchoolYearPeer::retrieveLastYearSchoolYear($this->getSchoolYear());
     $last_year_career_school_year = CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($this->getCareer(), $last_year_school_year);
     SchoolYearPeer::clearInstancePool();
     CareerSchoolYearPeer::clearInstancePool();
     $con = Propel::getConnection();
     try {
         $con->beginTransaction();
         $commissions = CoursePeer::retrieveComissionsForCareerSchoolYear($last_year_career_school_year);
         foreach ($commissions as $commission) {
             $commission->createCopyForSchoolYear($con, null, $this);
             $commission->clearAllReferences(true);
             unset($commission);
         }
         unset($commissions);
         $con->commit();
     } catch (PropelException $e) {
         $con->rollback();
         throw $e;
     }
 }
 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;
     }
 }
 public static function sorted(Criteria $c, $career = null)
 {
     $has_school_year = !is_null($career) && !is_null(CareerSchoolYearPeer::retrieveByCareerAndSchoolYear($this->getCareer(), SchoolYearPeer::retrieveCurrent()));
     if ($has_school_year) {
         CareerSubjectSchoolYearPeer::sorted($c);
     }
     $c->addAscendingOrderByColumn(SubjectPeer::NAME);
     $c->addJoin(self::SUBJECT_ID, SubjectPeer::ID);
 }