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');
     try {
         $connection->beginTransaction();
         $c = new Criteria();
         $c->add(StudentApprovedCareerSubjectPeer::SCHOOL_YEAR_ID, 1);
         $student_approved_career_subjects = StudentApprovedCareerSubjectPeer::doSelect($c);
         $arreglados = 0;
         foreach ($student_approved_career_subjects as $student_approved_career_subject) {
             if (!($student_approved_career_subject->hasStudentApprovedCourseSubject() || $student_approved_career_subject->hasStudentDisapprovedCourseSubject() || $student_approved_career_subject->hasStudentRepprovedCourseSubject())) {
                 $evaluetor = new LvmEvaluatorBehaviour();
                 $c = new Criteria();
                 $course_subject_student = CourseSubjectStudentPeer::retrieveByStudentApprovedCareerSubject($student_approved_career_subject, SchoolYearPeer::retrieveByPK(1));
                 if ($course_subject_student) {
                     $instanceResult = $evaluetor->getCourseSubjectStudentResult($course_subject_student, $connection);
                     if ($instanceResult instanceof StudentApprovedCourseSubject) {
                         $criteria = new Criteria();
                         $criteria->add(StudentApprovedCourseSubjectPeer::STUDENT_ID, $instanceResult->getStudentId());
                         $criteria->add(StudentApprovedCourseSubjectPeer::SCHOOL_YEAR_ID, $instanceResult->getSchoolYearId());
                         $criteria->add(StudentApprovedCourseSubjectPeer::COURSE_SUBJECT_ID, $instanceResult->getCourseSubjectId());
                         if (StudentApprovedCourseSubjectPeer::doCount($criteria)) {
                             $instanceResult = StudentApprovedCourseSubjectPeer::doSelectOne($criteria);
                         }
                         $instanceResult->setStudentApprovedCareerSubject($student_approved_career_subject);
                         $instanceResult->setStudentApprovedCareerSubjectId($student_approved_career_subject->getId());
                         $instanceResult->save();
                         $this->logSection("arreglado", $arreglados);
                         $this->logSection("alumno", $instanceResult->getStudent());
                         $this->logSection("careerSubject", $instanceResult->getCareerSubject());
                         $this->logSection("StudentApprovedCourseSubject", $instanceResult);
                         $this->logSection("StudentApprovedCareerSubject ID: ", $student_approved_career_subject->getId());
                         //var_dump($instanceResult);die();
                         $arreglados++;
                     }
                 } else {
                     $this->logSection("No se pudieron ubicar", $student_approved_career_subject->getStudent() . '- ' . $student_approved_career_subject->getCareerSubject() . '' . $student_approved_career_subject->getId());
                 }
             }
         }
         $this->logSection("arreglados", $arreglados);
         $connection->commit();
         $connection->beginTransaction();
         $c = new Criteria();
         $c->add(StudentApprovedCourseSubjectPeer::SCHOOL_YEAR_ID, 1);
         $c->add(StudentApprovedCourseSubjectPeer::STUDENT_APPROVED_CAREER_SUBJECT_ID, null, Criteria::ISNULL);
         //Se actualizan los cursos aprobados con la materia aprobada, esto existe por que hubo una version que no lo hacia de forma correcta y esto corrige dicho error.
         $update = 0;
         $news = 0;
         $student_approved_course_subjects_null = StudentApprovedCourseSubjectPeer::doSelect($c);
         foreach ($student_approved_course_subjects_null as $student_approved_course_subject) {
             $course_subject_student = $student_approved_course_subject->getCourseSubjectStudent();
             if ($course_subject_student) {
                 $student_approved_career_subject = StudentApprovedCareerSubjectPeer::retrieveOrCreateByCareerSubjectAndStudent($course_subject_student->getCourseSubject()->getCareerSubject()->getId(), $student_approved_course_subject->getCourseSubjectStudent()->getStudentId());
             } else {
                 $this->logSection("Cuak!", $student_approved_course_subject->getId(), $student_approved_course_subject);
             }
             $student_approved_career_subject->setSchoolYearId(1);
             $student_approved_course_subject->setStudentApprovedCareerSubject($student_approved_career_subject);
             $student_approved_career_subject->isNew() ? $news++ : $update++;
             $student_approved_course_subject->save($connection);
             $student_approved_career_subject->save($connection);
         }
         $this->logSection("Actualizados", $update);
         $this->logSection("Nuevos", $news);
         //Este foreach corrige el error de una version, que creaba tambien el student_approved_course_subject, cuando no es real.
         $c = new Criteria();
         $student_dissapproved_course_subjects = StudentDisapprovedCourseSubjectPeer::doSelect($c);
         $delete = 0;
         foreach ($student_dissapproved_course_subjects as $student_dissapproved_course_subject) {
             $course_subject_student = $student_dissapproved_course_subject->getCourseSubjectStudent();
             $c = new Criteria();
             $c->add(StudentApprovedCourseSubjectPeer::STUDENT_ID, $course_subject_student->getStudentId());
             $c->add(StudentApprovedCourseSubjectPeer::COURSE_SUBJECT_ID, $course_subject_student->getCourseSubjectId());
             $student_approved_course_subject = StudentApprovedCourseSubjectPeer::doSelectOne($c);
             if (!is_null($student_approved_course_subject)) {
                 $student_approved_course_subject->delete($connection);
                 $delete++;
             }
         }
         $this->logSection("Borrados", $delete);
         $connection->commit();
         /*
          $c = new Criteria();
          $c->add(StudentDisapprovedCourseSubjectPeer::STUDENT_APPROVED_CAREER_SUBJECT_ID, null, Criteria::ISNULL);
         
          $student_dissapproved_course_subjects = StudentDisapprovedCourseSubjectPeer::doSelect($c);
          foreach ($student_dissapproved_course_subjects as $student_dissapproved_course_subject)
          {
          $student_approved_career_subject = StudentApprovedCareerSubjectPeer::retrieveOrCreateByCareerSubjectAndStudent(
          $student_dissapproved_course_subject->getCourseSubjectStudent()->getCourseSubject()->getCareerSubject()->getId(),
          $student_dissapproved_course_subject->getCourseSubjectStudent()->getStudentId());
         
          if (!is_null($student_approved_career_subject) && !$student_approved_career_subject->isNew())
          {
          $student_dissapproved_course_subject->setStudentApprovedCareerSubjectId($student_approved_career_subject->getId());
          $student_dissapproved_course_subject->save($connection);
          }
          else
          {
          $student_repproved_course_subject = StudentRepprovedCourseSubjectPeer::retrieveCourseSubjectStudent($student_dissapproved_course_subject->getCourseSubjectStudent());
         
          if (is_null($student_repproved_course_subject))
          {
          die(var_dump($student_dissapproved_course_subject->getId()));
          }
          }
          }
         */
         //$this->fixComissions($connection);
         //$this->fixCourseSubjectStudents($connection);
         //$this->fixStudentCareerSchoolYearStatus($connection);
         //$this->fixRepetidores($connection);
         //$this->fixApproved($connection);
     } catch (PropelException $e) {
         $connection->rollback();
         throw $e;
     }
     // add your code here
 }
 public function closeCourseSubjectStudent($result, PropelPDO $con = null, $course_subject_student)
 {
     if ($result instanceof StudentApprovedCourseSubject) {
         $student_approved_career_subject = StudentApprovedCareerSubjectPeer::retrieveByCourseSubjectStudent($course_subject_student);
         if (is_null($student_approved_career_subject)) {
             $student_approved_career_subject = new StudentApprovedCareerSubject();
             $student_approved_career_subject->setCareerSubject($result->getCourseSubject($con)->getCareerSubject($con));
             $student_approved_career_subject->setStudent($result->getStudent($con));
             $student_approved_career_subject->setSchoolYear($result->getSchoolYear($con));
             $student_approved_career_subject->setMark($result->getMark());
             $result->setStudentApprovedCareerSubject($student_approved_career_subject);
             /* para el caso de que se aprueba por mesa de examen, se debe asociar el student_approved_career_subject
              * con el student_disapproved_course_subject
              */
             $disapproved = StudentDisapprovedCourseSubjectPeer::retrieveByStudentApprovedCourseSubject($result, $con);
             if (!is_null($disapproved)) {
                 $disapproved->setStudentApprovedCareerSubject($student_approved_career_subject);
                 $disapproved->save($con);
             }
             $student_approved_career_subject->save($con);
             $result->save($con);
         }
     } else {
         $this->createCourseSubjectStudentExamination($result->getCourseSubjectStudent(null, $con), $con);
     }
 }
 public function evaluateCareerSchoolYearStudent(CareerSchoolYear $career_school_year, Student $student, PropelPDO $con = null)
 {
     $con = is_null($con) ? Propel::getConnection() : $con;
     // obtenemos mas materias de este año
     #$course_subject_students = CourseSubjectStudentPeer::retrieveByCareerSchoolYearAndStudent($career_school_year, $student, $con);
     //$c = CourseSubjectStudentPeer::retrieveCriteriaByCareerSchoolYearAndStudent($career_school_year, $student, $con);
     //$c->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID, Criteria::INNER_JOIN);
     //$c->add(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, $this->getCurrentHistoriaDelArte()->getId(), Criteria::NOT_EQUAL);
     // para todas las materias cursadas este año
     //$course_subject_students = CourseSubjectStudentPeer::doSelect($c);
     $school_year = SchoolYearPeer::retrieveCurrent();
     $course_subject_students = $student->getCourseSubjectStudentsForSchoolYear($school_year);
     CourseSubjectStudentPeer::clearInstancePool();
     unset($school_year);
     foreach ($course_subject_students as $course_subject_student) {
         // obtenemos el resultado (aprobada o desaprobada) y la cerramos.
         // para el caso de las aprobadas, se crea la mesa de examen final (StudentApprovedCareerSubject)
         // de lo contrario, la inscripción a la mesa de examen (TODO)
         $result = $course_subject_student->getCourseResult($con);
         if (!is_null($result)) {
             $result->close($con);
             ###Liberando memoria ###
             $result->clearAllReferences(true);
             unset($result);
         }
         $course_subject_student->clearAllReferences(true);
         unset($course_subject_student);
         ###########################
     }
     ###Liberando memoria ###
     unset($course_subject_students);
     StudentApprovedCourseSubjectPeer::clearInstancePool();
     StudentDisapprovedCourseSubjectPeer::clearInstancePool();
     ################################
     if ($this->getCurrentHistoriaDelArte()) {
         $this->evaluateHistoriaDelArteCareerSchoolYearStudent($career_school_year, $student, $con);
     }
 }
 public function getApprovationInstance()
 {
     // Caso Regular: aprueba en primer instancia
     $instance = StudentApprovedCourseSubjectPeer::retrieveByStudentApprovedCareerSubject($this);
     if (!is_null($instance)) {
         return $instance;
     }
     // Caso Mesa de Diciembre, Marzo
     $instance = StudentDisapprovedCourseSubjectPeer::retrieveByStudentApprovedCareerSubject($this);
     if (!is_null($instance)) {
         return $instance;
     }
     // Caso de previa
     $instance = StudentRepprovedCourseSubjectPeer::retrieveByStudentApprovedCareerSubject($this);
     if (!is_null($instance)) {
         return $instance;
     }
     return null;
 }
 public function evaluateCareerSchoolYearStudent(CareerSchoolYear $career_school_year, Student $student, PropelPDO $con = null)
 {
     $con = is_null($con) ? Propel::getConnection() : $con;
     // obtenemos las materias de este año
     #$course_subject_students = CourseSubjectStudentPeer::retrieveByCareerSchoolYearAndStudent($career_school_year, $student, $con);
     $c = CourseSubjectStudentPeer::retrieveCriteriaByCareerSchoolYearAndStudent($career_school_year, $student, $con);
     $pager = new sfPropelPager('CourseSubjectStudent', 100);
     $pager->setCriteria($c);
     $pager->init();
     for ($i = 1; $i < $pager->getLastPage() + 1; $i++) {
         $course_subject_students = $pager->getResults();
         // para todas las materias cursadas este año
         foreach ($course_subject_students as $course_subject_student) {
             // obtenemos el resultado (aprobada o desaprobada) y la cerramos.
             // para el caso de las aprobadas, se crea la mesa de examen final (StudentApprovedCareerSubject)
             // de lo contrario, la inscripción a la mesa de examen (TODO)
             $result = $course_subject_student->getCourseResult($con);
             if (!is_null($result)) {
                 $result->close($con);
             }
         }
         ###Liberando memoria ###
         CourseSubjectStudentPeer::clearInstancePool();
         StudentApprovedCourseSubjectPeer::clearInstancePool();
         StudentDisapprovedCourseSubjectPeer::clearInstancePool();
         ################################
         $pager->setPage($pager->getPage() + 1);
         $pager->init();
     }
     unset($pager);
     unset($c);
 }
Esempio n. 6
0
 /**
  * This method back the period to last one.
  */
 public function backPeriod()
 {
     if ($this->getCurrentPeriod() == 1) {
         return null;
     }
     $con = Propel::getConnection();
     $con->beginTransaction();
     try {
         $c = new Criteria();
         $c->add(CourseSubjectStudentMarkPeer::MARK_NUMBER, $this->getCurrentPeriod() - 1);
         $c->addJoin(CourseSubjectStudentMarkPeer::COURSE_SUBJECT_STUDENT_ID, CourseSubjectStudentPeer::ID);
         $c->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
         $c->add(CourseSubjectPeer::COURSE_ID, $this->getId());
         $course_subject_students_marks = CourseSubjectStudentMarkPeer::doSelect($c);
         foreach ($course_subject_students_marks as $course_subject_student_mark) {
             $course_subject_student_mark->setIsClosed(false);
             $course_subject_student_mark->save($con);
             //Seleccionamos todos los StudentDisapprovedCourseSubjec y StudentApprovedCourseSubject si es que tiene y los borramos
             $c = new Criteria();
             $c->add(StudentDisapprovedCourseSubjectPeer::COURSE_SUBJECT_STUDENT_ID, $course_subject_student_mark->getCourseSubjectStudentId());
             StudentDisapprovedCourseSubjectPeer::doDelete($c);
             //eliminando StudentApprovedCourseSubject
             $c = new Criteria();
             $course_subject_student = CourseSubjectStudentPeer::retrieveByPK($course_subject_student_mark->getCourseSubjectStudentId());
             $c->add(StudentApprovedCourseSubjectPeer::STUDENT_ID, $course_subject_student->getStudentId());
             $c->add(StudentApprovedCourseSubjectPeer::COURSE_SUBJECT_ID, $course_subject_student->getCourseSubjectId());
             StudentApprovedCourseSubjectPeer::doDelete($c);
         }
         $this->setCurrentPeriod($this->getCurrentPeriod() - 1);
         $this->setIsClosed(false);
         $this->save($con);
         $con->commit();
     } catch (PropelException $e) {
         $con->rollBack();
         throw $e;
     }
 }
Esempio n. 7
0
 public function getStudentDisapprovedCourseSubject()
 {
     $last_year_school_year = SchoolYearPeer::retrieveLastYearSchoolYear(SchoolYearPeer::retrieveCurrent());
     if (!is_null($last_year_school_year)) {
         $criteria = new Criteria();
         $criteria->addJoin(CourseSubjectStudentPeer::STUDENT_ID, $this->getId());
         $criteria->addJoin(StudentDisapprovedCourseSubjectPeer::COURSE_SUBJECT_STUDENT_ID, CourseSubjectStudentPeer::ID);
         $criteria->addJoin(CourseSubjectStudentPeer::COURSE_SUBJECT_ID, CourseSubjectPeer::ID);
         $criteria->addJoin(CourseSubjectPeer::CAREER_SUBJECT_SCHOOL_YEAR_ID, CareerSubjectSchoolYearPeer::ID);
         $criteria->addJoin(CareerSubjectSchoolYearPeer::CAREER_SCHOOL_YEAR_ID, CareerSchoolYearPeer::ID);
         $criteria->add(CareerSchoolYearPeer::SCHOOL_YEAR_ID, $last_year_school_year->getId());
         return StudentDisapprovedCourseSubjectPeer::doSelect($criteria);
     }
 }
Esempio n. 8
0
 public function getLastStudentDisapprovedCourseSubject()
 {
     $c = new Criteria();
     $c->add(StudentDisapprovedCourseSubjectPeer::COURSE_SUBJECT_STUDENT_ID, $this->getId());
     $c->addDescendingOrderByColumn(StudentDisapprovedCourseSubjectPeer::EXAMINATION_NUMBER);
     return StudentDisapprovedCourseSubjectPeer::doSelectOne($c);
 }