Symfony Profiler

<?php
namespace App\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Security\Core\Security;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Annotation\Route;
use Knp\Component\Pager\PaginatorInterface;
use App\Entity\Courses;
use App\Entity\DocumentsTypes;
use App\Entity\Levels;
use App\Entity\Modules;
use App\Entity\Students;
use App\Entity\StudentCourse;
use App\Entity\StudentEvaluation;
use App\Entity\StudentEvaluationAnswer;
use App\Entity\StudentEvaluationPostRevision;
use App\Entity\StudentLevels;
use App\Entity\StudentModule;
use App\Entity\User;
use App\Utilities\Utilities;
use DateTime;
class StudentController extends AbstractController {
private $userPasswordHasher;
private $security;
public function __construct(Security $security) {
date_default_timezone_set('America/Bogota');
$this->security = $security;
}
public function index(PaginatorInterface $paginator, Request $request) {
$myDate = new DateTime('now');
$names = trim($request->get('names'));
$lastname = trim($request->get('lastname'));
$email = trim($request->get('email'));
$phone = trim($request->get('phone'));
$identification = trim($request->get('identification'));
$checkProcessTest = trim($request->get('checkProcessTest'));
$modality = trim($request->get('modality'));
$campus = trim($request->get('campus'));
$em = $this->getDoctrine()->getManager();
$filters = false;
if ($this->validateFilter([$names, $lastname, $email, $phone, $identification, $checkProcessTest, $modality, $campus])) {
$filters = true;
}
// listado de estudiantes
$studentList = $em->getRepository(Students::class)
->getStudentList($names, $lastname, $email, $phone, $identification, $checkProcessTest, $modality, $campus);
$list = $paginator->paginate(
$studentList,
$request->query->getInt('page', 1),
50
);
// obtener los niveles por cada estudiante
$arrStudentLevel = [];
foreach($list->getItems() as $myStudent) {
// obtener los studen_level
$level = $em->getRepository(StudentLevels::class)->getStudentLevel($myStudent);
$lastModule = $em->getRepository(StudentModule::class)->getModuleScheduled($myDate, $myStudent);
$arrStudentLevel[$myStudent->getId()] = ['level' => $level, 'module' => $lastModule];
}
return $this->render('student/index.html.twig', [
'controller_name' => 'StudentController',
'listdata' => $list,
'studentLevel' => $arrStudentLevel,
'filters' => $filters,
'names' => $names,
'lastname' => $lastname,
'email' => $email,
'phone' => $phone,
'identification' => $identification,
'checkProcessTest' => $checkProcessTest,
'modality' => $modality,
'campus' => $campus,
]);
}
public function new() {
$em = $this->getDoctrine()->getManager();
$documentsTypes = $em->getRepository(DocumentsTypes::class)->findAll();
$courses = $em->getRepository(Courses::class)->findAll();
return $this->render('student/new.html.twig', [
'documentsTypes' => $documentsTypes,
'courses' => $courses,
]);
}
public function create(Request $request, UserPasswordHasherInterface $userPasswordHasher) {
$em = $this->getDoctrine()->getManager();
$dateNow = new DateTime('now');
$docutmenType = $em->getRepository(DocumentsTypes::class)->find($request->get('stdDocumentType'));
$course = $em->getRepository(Courses::class)->find($request->get('stdCourse'));
$level = $em->getRepository(Levels::class)->find($request->get('stdcourse-level'));
/*
* crear usuario y luego el estudiante para asociarle el usuario
*/
$this->userPasswordHasher = $userPasswordHasher;
$studenDni = preg_replace('/[^\da-z]/i', '', $request->get('stdIdentification'));
$usFullname = $request->get('stdname') . ' ' . $request->get('stdlastname');
$user = $this->praxisNewUser($studenDni, $usFullname);
/*
* Crear nuevo registro en Student
*/
$util = new Utilities();
$util->setEm($em);
$data = [
'stdCourse' => $request->get('stdCourse'),
'stdcourseLevel' => $request->get('stdcourse-level'),
'stdDocumentType' => $request->get('stdDocumentType'),
'stdname' => $request->get('stdname'),
'stdlastname' => $request->get('stdlastname'),
'stdIdentification' => $studenDni,
'stdPhone' => $request->get('stdPhone'),
'stdEmail' => $request->get('stdEmail'),
'stdCity' => $request->get('stdCity'),
'stdAddress' => $request->get('stdAddress'),
'stdCampus' => $request->get('stdCampus'),
'stdModality' => $request->get('stdModality'),
'stdEPS' => $request->get('stdEPS'),
'stdContact' => $request->get('stdContact'),
'stdContactPhone' => $request->get('stdContactPhone'),
];
$util->createStudent($data, $user);
$redirectUrl = $this->generateUrl('admin_student_list') . '?identification=' . $request->get('stdIdentification');
return $this->redirect($redirectUrl);
}
public function edit($id) {
$em = $this->getDoctrine()->getManager();
$documentsTypes = $em->getRepository(DocumentsTypes::class)->findAll();
$courses = $em->getRepository(Courses::class)->findAll();
$student = $em->getRepository(Students::class)->find($id);
$studentLevel = $em->getRepository(StudentLevels::class)->findOneBy(['student' => $id]);
$myCourse = $studentLevel->getLevel()->getCourse();
$myLevels = $em->getRepository(Levels::class)->findAll(['course' => $myCourse], ['sequence' => 'ASC']);
return $this->render('student/edit.html.twig', [
'documentsTypes' => $documentsTypes,
'courses' => $courses,
'student' => $student,
'studentLevel' => $studentLevel,
'myLevels' => $myLevels,
]);
}
public function update(Request $request) {
$id = $request->get('stdudentid');
$em = $this->getDoctrine()->getManager();
$student = $em->getRepository(Students::class)->find($id);
$docutmenType = $em->getRepository(DocumentsTypes::class)->find($request->get('stdDocumentType'));
$student->setNames(mb_strtoupper($request->get('stdname'), 'UTF-8'));
$student->setLastname(mb_strtoupper($request->get('stdlastname'), 'UTF-8'));
$student->setDocumentType($docutmenType);
$student->setDocumentNumber($request->get('stdIdentification'));
$student->setPhone($request->get('stdPhone'));
$student->setEmail($request->get('stdEmail'));
$student->setCity(mb_strtoupper($request->get('stdCity'), 'UTF-8'));
$student->setAddress(mb_strtoupper($request->get('stdAddress'), 'UTF-8'));
$student->setCampus(mb_convert_case($request->get('stdCampus'), MB_CASE_TITLE, 'UTF-8'));
$student->setModality(mb_convert_case($request->get('stdModality'), MB_CASE_TITLE, 'UTF-8'));
// $student->setEps(mb_strtoupper($request->get('stdEPS'), 'UTF-8'));
// $student->setParent(mb_strtoupper($request->get('stdContact'), 'UTF-8'));
// $student->setParentPhone($request->get('stdContactPhone'));
$em->persist($student);
$em->flush();
$redirectUrl = $this->generateUrl('admin_student_list') . '?identification=' . $request->get('stdIdentification');
return $this->redirect($redirectUrl);
}
public function modules($studentid) {
$em = $this->getDoctrine()->getManager();
/*
* en caso que el usuario logeado no sea ADMIN se consulta el estudiante
* esto para evitar que estudiantes vean información de los demás
*/
if (!in_array('ROLE_ADMIN', $this->getUser()->getRoles()) && !in_array('ROLE_TEACHER', $this->getUser()->getRoles())) {
$student = $em->getRepository(Students::class)->findOneBy(['user' => $this->getUser()->getId(), 'id' => $studentid]);
if(empty($student)) {
// return to home
return $this->redirectToRoute('app_home');
}
$studentid = $student->getId();
}
$student = $em->getRepository(Students::class)->find($studentid);
// obtener el ultimo nivel del estudiante
$studentLevels = $em->getRepository(StudentLevels::class)->findBy(['student' => $studentid], ['level' => 'DESC']);
// obtener todos los modulos activados al estudiante
$studentModules = $em->getRepository(StudentModule::class)->findBy(['student' => $studentid]);
// obtener los modulos del nivel actual cursado
$modules = $em->getRepository(Modules::class)->getModulesByLevels($studentLevels);
$modulesHistory = [];
foreach ($modules as $module) {
$checked = false;
$approved = false;
$score = 0;
$scoreReading = 0;
$scoreWriting = 0;
$scoreListening = 0;
$scoreSpeaking = 0;
$stdAttempts = 0;
$available = 0;
$enbSince = null;
$enbUntil = null;
$presentedAt = null;
$checkedAt = null;
//
foreach ($studentModules as $stdModule) {
if ($stdModule->getModule() == $module) {
$checked = true;
$score = $stdModule->getScore();
$approved = $stdModule->getApproved();
$available = $stdModule->getAvailable();
$enbSince = $stdModule->getEnableSince();
$enbUntil = $stdModule->getEnableUntil();
break;
}
}
// obtener los registros de la ultima evaluación del estudiante
$studentEvaluation = $em->getRepository(StudentEvaluation::class)
->findOneBy(['module' => $module->getId(), 'student' => $studentid], ['id' => 'DESC']);
if (!empty($studentEvaluation)) {
$scoreReading = $studentEvaluation->getScoreReading();
$scoreWriting = $studentEvaluation->getScoreWriting();
$scoreListening = $studentEvaluation->getScoreListening();
$scoreSpeaking = $studentEvaluation->getScoreSpeaking();
$stdAttempts = $studentEvaluation->getAttemps();
$presentedAt = $studentEvaluation->getPresentedAt();
$checkedAt = $studentEvaluation->getCheckedAt();
}
$modulesHistory[] = [
'moduleId' => $module->getId(),
'courseName' => $module->getLevel()->getCourse()->getName(),
'moduleName' => $module->getName(),
'scoreReading' => $scoreReading,
'scoreWriting' => $scoreWriting,
'scoreListening' => $scoreListening,
'scoreSpeaking' => $scoreSpeaking,
'moduleScore' => $score,
'minScore' => $module->getScoreMinimun(),
'evaluationStatus' => !empty($studentEvaluation) ? $studentEvaluation->getStatus() : 'NONE',
'levelId' => $module->getLevel()->getId(),
'levelName' => $module->getLevel()->getName(),
'isChecked' => $checked,
'approved' => $approved,
'available' => $available,
'enbSince' => $enbSince,
'enbUntil' => $enbUntil,
'enabled' => $module->getEnableShow(),
'studentEvaluation' => $studentEvaluation,
'attempts' => $stdAttempts,
'presentedAt' => $presentedAt,
'checkedAt' => $checkedAt,
];
}
return $this->render('student/modules.html.twig', [
'student' => $student,
'moduleHistory' => $modulesHistory,
]);
}
public function makeEvaluation($student, $module, Request $request) {
$em = $this->getDoctrine()->getManager();
// obtener el modulo del estudiante para validar que este disponible para continuar
$studentModule = $em->getRepository(StudentModule::class)->findOneBy(['module' => $module, 'student' => $student]);
$studentEvaluation = $em->getRepository(StudentEvaluation::class)
->findOneBy(['module' => $module, 'student' => $student], ['attemps' => 'DESC']);
if(!empty($studentEvaluation)) {
if($studentEvaluation->getStatus() == StudentEvaluation::STATUS_IN_PROCESS || $studentEvaluation->getApproved() == 1) {
return $this->redirectToRoute('student_modules', ['studentid' => $studentEvaluation->getStudent()->getId()]);
}
}
$myModule = $studentModule->getModule();
$myStudent = $studentModule->getStudent();
// validar si el modulo ya esta evaluado y aprobado TODO
$isAvailable = 1;
if($studentModule->getAvailable() != 1) {
$isAvailable = 0;
}
return $this->render('student/makeEvaluation.html.twig', [
'myModule' => $myModule,
'myStudent' => $myStudent,
'isAvailable' => $isAvailable,
'attemps' => empty($studentEvaluation) ? 0 : $studentEvaluation->getAttemps(),
]);
}
/**
* Almacenar las respuestas del estudiante esto es para que luego el profesor califique
* @param Request $request
* @return JsonResponse
*/
public function saveEvaluationAnswers(Request $request) {
$myAnswers = json_decode($request->get('answers'));
$myModule = $request->get('module');
$studentId = $request->get('studentId');
$myFullScore = round($request->get('fullScore'), 2);
$myScore = round($request->get('myScore'), 2);
$em = $this->getDoctrine()->getManager();
// obtener el estudiante segun el usuario logeado
$student = $em->getRepository(Students::class)->find($studentId);
// validar si el estudiante esta logeado
if (empty($student)) {
return new JsonResponse(['msn' => '__KO__', 'evaluationId' => 0,
'score' => 0, 'approved' => 0]);
}
// obtener el modulo que se esta evaluando
$module = $em->getRepository(Modules::class)->find($myModule);
// obtener el puntaje minimo para aprobar el modulo
$moduleScoreMinimun = $module->getScoreMinimun();
// incrementar los intentos cuando presenta el examen
$studentEval = $em->getRepository(StudentEvaluation::class)
->findBy(['student' => $student->getId(), 'module' => $module->getId()]);
$attemps = count($studentEval) + 1;
// crear un nuevo registro de StudentEvaluation para almacenar las respuestas dadas
$studentEvaluation = new StudentEvaluation();
$studentEvaluation->setAttemps($attemps);
$studentEvaluation->setModule($module);
$studentEvaluation->setStudent($student);
$studentEvaluation->setAllPoints($myFullScore);
$studentEvaluation->setGettedPoints($myScore);
$studentEvaluation->setScoreMinimun($moduleScoreMinimun);
$studentEvaluation->setStatus(StudentEvaluation::STATUS_IN_PROCESS);
$student->setHasInProcessTest(Students::STUDENT_HAS_IN_PROGRESS_TEST_YES);
$em->persist($student);
// almacenar las respuestas
$scoreReading = [0, 0, 0];
$scoreWriting = [0, 0, 0];
$scoreListening = [0, 0, 0];
$scoreSpeaking = [0, 0, 0];
foreach ($myAnswers as $answersx) {
$answers = new StudentEvaluationAnswer();
$answers->setPoints($answersx->score); // puntaje de la pregunta
$answers->setScore(round($answersx->scoreGot, 2)); // puntaje obtenido en la calificacion previa a la validacion del docente
$answers->setQuestion($answersx->questionText); // la formulacion de la pregunta
$answers->setAnswerSkillType($answersx->questionSkill); // el tipo de pregunta y la habilidad
$answers->setRightAnswer($answersx->rightAnswer); // esta es la respuesta correcta esperada
$answers->setAnswerGiven($answersx->answerGiven); // respuesta dada por el estudiante
$answers->setIsChecked($answersx->checked); // respuesta validada y calificada
$answers->setAnswerType($answersx->answerType); // tipo de la respuesta
$answers->setStudentEvaluation($studentEvaluation); // asociar la evaluacion al estudiante
$em->persist($answers);
// calcular los porcentajes por habilidad
if($answersx->questionSkill == 'reading') {
$scoreReading[0] += $answersx->score;
$scoreReading[1] += $answersx->scoreGot;
} elseif($answersx->questionSkill == 'writing') {
$scoreWriting[0] += $answersx->score;
$scoreWriting[1] += $answersx->scoreGot;
} elseif($answersx->questionSkill == 'listening') {
$scoreListening[0] += $answersx->score;
$scoreListening[1] += $answersx->scoreGot;
} elseif($answersx->questionSkill == 'speaking') {
$scoreSpeaking[0] += $answersx->score;
$scoreSpeaking[1] += $answersx->scoreGot;
}
}
$scoreReading[2] = $scoreReading[1] * 100 / $scoreReading[0];
$scoreWriting[2] = $scoreWriting[1] * 100 / $scoreWriting[0];
$scoreListening[2] = $scoreListening[1] * 100 / $scoreListening[0];
$scoreSpeaking[2] = $scoreSpeaking[1] * 100 / $scoreSpeaking[0];
$stdEvalScore = ($scoreSpeaking[2] + $scoreListening[2] + $scoreWriting[2] + $scoreReading[2]) / 4;
$moduleApproved = $stdEvalScore >= $moduleScoreMinimun ? 1 : 0;
$studentEvaluation->setScoreReading(round($scoreReading[2], 2));
$studentEvaluation->setScoreWriting(round($scoreWriting[2], 2));
$studentEvaluation->setScoreListening(round($scoreListening[2], 2));
$studentEvaluation->setScoreSpeaking(round($scoreSpeaking[2], 2));
$studentEvaluation->setPresentedAt(new DateTime('now'));
$studentEvaluation->setScore(round($stdEvalScore, 2));
$studentEvaluation->setApproved($moduleApproved);
$em->persist($studentEvaluation);
$em->flush();
return new JsonResponse(['msn' => '__OK__', 'evaluationId' => $studentEvaluation->getId(),
'score' => $stdEvalScore, 'approved' => $moduleApproved]);
}
public function reOpenExamToSetRating($evaluationId) {
$em = $this->getDoctrine()->getManager();
$myEvaluation = $em->getRepository(StudentEvaluation::class)
->find($evaluationId);
$myEvaluation->setStatus(StudentEvaluation::STATUS_IN_PROCESS);
$myAnswers = $em->getRepository(StudentEvaluationAnswer::class)
->findBy(['studentEvaluation' => $myEvaluation, 'answerType' => 'opened']);
foreach($myAnswers as $answer) {
$arrPostReview = $answer->getStudentEvaluationPostRevisions();
foreach($arrPostReview as $postReview) {
$em->remove($postReview);
}
$answer->setIsChecked(false);
$answer->setScore(0);
$em->persist($answer);
}
$em->persist($myEvaluation);
$em->flush();
return $this->redirectToRoute('student_view_test', [
'student' => $myEvaluation->getStudent()->getId(),
'module' => $myEvaluation->getModule()->getId(),
'evaluationid' => 0
], Response::HTTP_SEE_OTHER);
}
public function viewEvaluation($student, $module, $evaluationid = 0) {
$em = $this->getDoctrine()->getManager();
// obtener la ultima evaluacion del estudiante
$arrEvaluationParams = ['student' => $student, 'module' => $module];
if(!empty($evaluationid)) {
$arrEvaluationParams = ['student' => $student, 'module' => $module, 'id' => $evaluationid];
}
$myEvaluation = $em->getRepository(StudentEvaluation::class)
->findOneBy($arrEvaluationParams, ['id' => 'DESC']);
if(empty($myEvaluation)) {
return $this->redirectToRoute('admin_student_modules', ['studentid' => $student], Response::HTTP_SEE_OTHER);
}
// obtener las respuestas de esa evaluacion
$myEvaluationAnswer = $em->getRepository(StudentEvaluationAnswer::class)
->findBy(['studentEvaluation' => $myEvaluation->getId()]);
return $this->render('student/viewEvaluation.html.twig', [
'module' => $myEvaluation->getModule(),
'evaluation' => $myEvaluation,
'evaluationAnswer' => $myEvaluationAnswer,
'student' => $myEvaluation->getStudent(),
]);
}
/**
* Almacenar un archivo audio
* @param Request $request
* @return JsonResponse
*/
public function studentUploadRecordingAudio(Request $request) {
$dir = $this->getParameter('kernel.project_dir') . '/public/logs/';
$fileMade = $dir . $this->getParameter('audio_logfile') . date('-Ymd') . '.log';
Utilities::setLogFile($fileMade, 'Inicio almacenar audio');
$fileName = $request->get('name') . '.wav';
try {
$file = $request->files->get('playload');
$fileOrigName = $file->getClientOriginalName();
$filePath = $this->getParameter('uploads_directory') . '/recording';
Utilities::setLogFile($fileMade, $fileOrigName . ' Nombre archivo ');
$file->move($filePath, $fileName);
Utilities::setLogFile($fileMade, $fileOrigName . ' Moviendo archivo archivo ');
$response = new JsonResponse([
'filePath' => '/uploads/recording/' . $fileName
]);
$response->setStatusCode(200);
Utilities::setLogFile($fileMade, $fileOrigName . ' Respondiendo al cliente');
return $response;
} catch (Exception $ex) {
Utilities::setLogFile($fileMade, sprintf('ERROR al guardar archivo %s , Mensaje %s', $fileName, $ex->getMessage()));
$error = new JsonResponse(['error' => $ex->getMessage()]);
$error->setStatusCode(500);
return $error;
}
}
/**
* Por cada respuesta abierta guardar la calificacion del docente
* @param Request $request
* @return JsonResponse
*/
public function savePostRevision(Request $request) {
$answerId = $request->get('answerId');
$revisionId = $request->get('revisionid');
$observation = $request->get('observation');
$scoreVal = round($request->get('scoreVal'), 2);
$em = $this->getDoctrine()->getManager();
// obtener las respuestas de esa evaluacion
$myEvaluationAnswer = $em->getRepository(StudentEvaluationAnswer::class)->find($answerId);
$myEvaluation = $myEvaluationAnswer->getStudentEvaluation();
$answerScore = $myEvaluationAnswer->getScore(); // puntaje obtenido en esta pregunta
$sumScore = $answerScore + $scoreVal;
$postRevision = new StudentEvaluationPostRevision();
// en caso que la revision exista se le resta ese puntaje al neuvo score
if(!empty($revisionId)) {
$postRevision = $em->getRepository(StudentEvaluationPostRevision::class)->find($revisionId);
$sumScore -= $postRevision->getScore();
}
// calcular el nuevo puntale obtenido en la evaluacion
$examVal = $myEvaluation->getGettedPoints() - $answerScore + $sumScore;
// calcular el porcentaje obtenido
$examPercent = round($examVal / $myEvaluation->getAllPoints() * 100 , 2);
$myEvaluation->setGettedPoints(round($examVal, 2));
$postRevision->setObservation($observation);
$postRevision->setScore($scoreVal);
$postRevision->setAnswer($myEvaluationAnswer);
$myEvaluationAnswer->setScore(round($sumScore, 2));
$myEvaluationAnswer->setIsChecked(true);
$em->persist($myEvaluation);
$em->persist($myEvaluationAnswer);
$em->persist($postRevision);
$em->flush();
return new JsonResponse(['revisionid' => $postRevision->getId(), 'evaluationScore' => $examPercent]);
}
/**
* cerrar la calificacion del docente y validar si el examen fue aprobado
* tambien promedia los resultados en las 4 habilidad comunicativas
* para activar el siguiente modulo al estudiante
* @param Request $request
* @return JsonResponse
*/
public function closeEvaluation(Request $request) {
$evaluationId = $request->get('evaluationId');
$studentId = $request->get('studentId');
$moduleId = $request->get('moduleId');
$em = $this->getDoctrine()->getManager();
// obtener el registro StudenEvaluation
// # a este objeto se le deben actualizar los promedios para las 4 habilidades
$studentEvaluation = $em->getRepository(StudentEvaluation::class)
->find($evaluationId);
$stdEvaluationInProcess = $em->getRepository(StudentEvaluation::class)
->getInProcess($studentId, $moduleId);
$sumTotalScored = $this->calculatePonderatedSkills($evaluationId, $studentEvaluation);
$studentEvaluation->setScore(round($sumTotalScored, 2));
$realStudent = $studentEvaluation->getStudent();
// obtener el registro de StudenModule
$myStudentModule = $em->getRepository(StudentModule::class)
->findOneBy(['student' => $studentId, 'module' => $moduleId], ['id' => 'DESC']);
// validar el puntaje obtenido para aprobar o no el examen
$myDate = new DateTime('now');
$approved = ($studentEvaluation->getScore() >= $studentEvaluation->getScoreMinimun()) ? 1 : 0;
$studentEvaluation->setStatus(StudentEvaluation::STATUS_FINISHED);
$studentEvaluation->setApproved($approved);
$studentEvaluation->setCheckedAt($myDate);
$myStudentModule->setFinishedAt($myDate);
$myStudentModule->setScore($studentEvaluation->getScore());
$myStudentModule->setApproved($approved);
// desactivar el examen actual para evitar que lo vuelvan a presentar
$myStudentModule->setAvailable(0);
// consultar si el estudiante tiene mas evaluaciones pendientes por calificar
// la presente evaluacion se cuenta como
if (count($stdEvaluationInProcess) == 0) {
$myStudentModule->getStudent()->setHasInProcessTest(Students::STUDENT_HAS_IN_PROGRESS_TEST_NO);
} else {
$myStudentModule->getStudent()->setHasInProcessTest(Students::STUDENT_HAS_IN_PROGRESS_TEST_YES);
}
$em->persist($myStudentModule);
$em->persist($studentEvaluation);
/*
* Validar si el examen fue aprobado y que sea un modulo que valida el nivel
* para activar el siguiente nivel en el modulo
*/
$typeExamLevelModule = 'module';
$typeExamName = $myStudentModule->getModule()->getName();
$scRead = round(($studentEvaluation->getScoreReading()/10), 0);
$scWrit = round(($studentEvaluation->getScoreWriting()/10), 0);
$scList = round(($studentEvaluation->getScoreListening()/10), 0);
$scSpek = round(($studentEvaluation->getScoreSpeaking()/10), 0);
$scScore = round(($studentEvaluation->getScore()/10), 0);
if ($myStudentModule->getModule()->getThisValidateLevel() == 1) {
/*
* Obtener los valores cuando el examen es para evaluar un nivel
*/
$typeExamLevelModule = 'level';
$typeExamName = $myStudentModule->getModule()->getLevel()->getName();
$scRead = round(($studentEvaluation->getScoreReading()/10), 2);
$scWrit = round(($studentEvaluation->getScoreWriting()/10), 2);
$scList = round(($studentEvaluation->getScoreListening()/10), 2);
$scSpek = round(($studentEvaluation->getScoreSpeaking()/10), 2);
$scScore = round(($studentEvaluation->getScore()/10), 2);
}
if ($approved == 1 && $myStudentModule->getModule()->getThisValidateLevel() == 1) {
// al haber aprobado este modulo se habilita el siguiente modulo,
// marcando availabel=1 para StudentModule
$levelSequence = $myStudentModule->getModule()->getLevel()->getSequence();
$levelCourse = $myStudentModule->getModule()->getLevel()->getCourse()->getId();
// obtener el siguiente módulo, no necesariamente es un nuevo nivel
$nextModule = $em->getRepository(Modules::class)->getNextLevel($levelCourse, $levelSequence);
if (!empty($nextModule)) {
/*
* No se permite activar el siguiente modulo
* @deprecated obtener el modulo para activarlo y se pueda presentar la evaluacion
*/
$nextStudentModule = $em->getRepository(StudentModule::class)
->findOneBy(['student' => $studentId, 'module' => $nextModule->getId()]);
if (!empty($nextStudentModule)) {
$nextStudentModule->setAvailable(0);
$nextStudentModule->setApproved(0);
} else {
// si el estudiante no tiene el modulo registrado se crea el registro
$nextStudentModule = new StudentModule();
$nextStudentModule->setStudent($realStudent);
$nextStudentModule->setModule($nextModule);
$nextStudentModule->setAvailable(0);
$nextStudentModule->setApproved(0);
}
$em->persist($nextStudentModule);
// en caso que el nivel actual sea diferente al nivel del siguiente modulo se crea el registro en StudentLevel
if($nextStudentModule->getModule()->getlevel() != $myStudentModule->getModule()->getLevel()) {
$nextLevel = $nextStudentModule->getModule()->getlevel();
$newStudenLevel = new StudentLevels();
$newStudenLevel->setStudent($realStudent);
$newStudenLevel->setLevel($nextLevel);
$newStudenLevel->setCreatedAt(new DateTime('now'));
$em->persist($newStudenLevel);
}
}
}
$em->flush();
/*
* enviar al WS las calificaciones
*/
$util = new Utilities();
$url = $this->getParameter('api_setcalification_url');
$data = "{\"id\":\"" . trim($realStudent->getDocumentNumber()) . "\"" .
", \"type\":\"" . trim($typeExamLevelModule) . "\"" .
", \"typeName\":\"" .trim($typeExamName) . "\"" .
", \"listening\": " . number_format($scList, 2, '.', '') .
", \"reading\":" . number_format($scRead, 2, '.', '') .
", \"speaking\":" . number_format($scSpek, 2, '.', '') .
", \"writing\":" . number_format($scWrit, 2, '.', '') .
", \"score\":" . number_format($scScore, 2, '.', '') . "}";
$username = $this->getParameter('api_query_user');
$password = $this->getParameter('api_query_pass');
$fileMade = $this->getParameter('log_file') . date('-Ymd') . '.log';
$projectDir = $this->getParameter('project_dir_path') . '/var/log';
$resultcurl = $util->curlResultTest($url, $data, true, $username, $password);
$util->setDirectoryPath($projectDir);
$docNewLine = '> CURL Envio notas' . PHP_EOL . json_encode($data) . PHP_EOL . json_encode($resultcurl);
$util->writeLogFile($fileMade, $docNewLine);
return new JsonResponse(['studentModule' => $myStudentModule->getId(), 'moduleApproved' => $approved]);
}
private function calculatePonderatedSkills($evaluationId, $studentEvaluation) {
$em = $this->getDoctrine()->getManager();
$pintsSkill = $em->getRepository(StudentEvaluationAnswer::class)->getSumPointsToQuestionsBySkill($evaluationId);
$sumTotalScored = 0;
// obtener los ponderados del 25% para cada habilidad
foreach ($pintsSkill as $pointSkill) {
$ponderated = round($pointSkill['scoredExam'] * 100 / $pointSkill['totalExam'], 2);
if ($pointSkill['skill'] == 'listening') {
$sumTotalScored += $ponderated;
$studentEvaluation->setScoreListening($ponderated);
} elseif ($pointSkill['skill'] == 'reading') {
$sumTotalScored += $ponderated;
$studentEvaluation->setScoreReading($ponderated);
} elseif ($pointSkill['skill'] == 'speaking') {
$sumTotalScored += $ponderated;
$studentEvaluation->setScoreSpeaking($ponderated);
} elseif ($pointSkill['skill'] == 'writing') {
$sumTotalScored += $ponderated;
$studentEvaluation->setScoreWriting($ponderated);
}
}
return $sumTotalScored / 4;
}
public function activateModule(Request $request) {
$moduleId = $request->get('moduleId');
$studentId = $request->get('studentId');
$action = $request->get('action');
$em = $this->getDoctrine()->getManager();
$studentModule = $em->getRepository(StudentModule::class)->findOneBy(['student' => $studentId, 'module' => $moduleId]);
if(empty($studentModule)) {
return new JsonResponse(['msn' => '__KO__', 'isAvailable' => $action]);
}
$studentModule->setAvailable($action);
$em->persist($studentModule);
$em->flush();
return new JsonResponse(['msn' => '__OK__', 'isAvailable' => $action]);
}
public function praxisMakeTest($cardid, $module, UserPasswordHasherInterface $userPasswordHasher, Request $request) {
// decodificar los parametros para obtener la identificacion y el modulo para el test
$studentCardId = trim(base64_decode($cardid));
$moduleId = trim(base64_decode($module));
// buscar o crear el estudiante y el usuario
$em = $this->getDoctrine()->getManager();
$student = $em->getRepository(Students::class)->findOneBy(['documentNumber' => $studentCardId]);
$module = $em->getRepository(Modules::class)->getModuleLikeName($moduleId);
$user = null;
if(empty($module)) {
return $this->render('default/error.html.twig', [
'message' => "YOU DON'T HAVE ACCESS TO THIS PAGE"
]);
}
if (!empty($student)) {
$user = $student->getUser();
} else {
$dateNow = new DateTime('now');
// crear el estudiante y usuario en caso que no exista
$this->userPasswordHasher = $userPasswordHasher;
$user = $this->praxisNewUser($studentCardId, "Student $studentCardId");
$student = new Students();
$student->setDocumentNumber($studentCardId);
$student->setNames('name ' . $studentCardId);
$student->setLastname('lastname ' . $studentCardId);
$student->setHasInProcessTest(0);
$student->setUser($user);
$em->persist($student);
//crear registro de la tabla intermedia estudiante_curso
$course = $em->getRepository(Courses::class)->findOneBy([], ['id' => 'ASC']);
$studentCourse = new StudentCourse();
$studentCourse->setStudent($student);
$studentCourse->setCourse($course);
$studentCourse->setInitDate($dateNow);
$em->persist($studentCourse);
// crear registro de la tabla intermedia estudiante_level
$level = $module->getLevel();
$studentLevel = new StudentLevels();
$studentLevel->setStudent($student);
$studentLevel->setLevel($level);
$studentLevel->setCreatedAt($dateNow);
$em->persist($studentLevel);
//obtener todos los modulos del nivel actual y de los siguientes
$modulesByLevel = $em->getRepository(Levels::class)->getModulesGTlevel($level);
foreach($modulesByLevel as $modulex) {
// Agregar student_module los modulos del nivel en esatdo desabilitado
$isAvailable = ($module == $modulex) ? 1 : 0;
$stModul = new StudentModule();
$stModul->setAvailable($isAvailable);
$stModul->setModule($modulex);
$stModul->setStudent($student);
$em->persist($stModul);
}
$em->flush();
}
$session = new Session();
$session->start();
$session->set('user', $user);
// 'student_make_test',{'student': student.id, 'module': module.moduleId}
return $this->redirectToRoute('app_home');
}
private function praxisNewUser($cardtId, $fullname = '---') {
$em = $this->getDoctrine()->getManager();
// consultar si el estudiante existe
$userQ = $em->getRepository(User::class)->findOneBy(['username' => $cardtId]);
if(!empty($userQ)) {
return $userQ;
}
$user = new User();
$user->setUsername($cardtId);
$user->setFullname($fullname);
$user->setIsActive(true);
$user->setRoles(['ROLE_USER', 'ROLE_STUDENT']);
$user->setPassword($this->userPasswordHasher->hashPassword($user, $cardtId));
$em->persist($user);
$em->flush();
return $user;
}
/**
* @Route("/login_check", name="login_check")
*/
// public function someAction(NotifierInterface $notifier, LoginLinkHandlerInterface $loginLinkHandler, Request $request): Response {
public function someAction(Request $request) {
dd(333);
$expires = $request->get('expires');
$username = $request->get('user');
$hash = $request->get('hash');
dd($hash);
// get the user to be authenticated
$em = $this->getDoctrine()->getManager();
$user = $em->getRepository(User::class)->findOneBy(['username' => '1022334123']);
dd($user);
// log the user in on the current firewall
$this->security->login($user);
dd($user);
// if the firewall has more than one authenticator, you must pass it explicitly
// by using the name of built-in authenticators...
$this->security->login($user, 'form_login');
// ...or the service id of custom authenticators
$this->security->login($user, ExampleAuthenticator::class);
// you can also log in on a different firewall
$this->security->login($user, 'form_login', 'other_firewall');
// ... redirect the user to its account page for instance
}
/**
* Validar los valores de un array y si alguno no es vacio se retorna true <br>
* en caso que todos esten vacios se retorna false
* @param type $arrFileds
* @return boolean true|false
*/
private function validateFilter($arrFileds) {
$hasFilter = false;
foreach($arrFileds as $filter) {
if(!empty($filter)) {
$hasFilter = true;
break;
}
}
return $hasFilter;
}
public function reportTestsScore(PaginatorInterface $paginator, Request $request) {
$em = $this->getDoctrine()->getManager();
$course = trim($request->get('course'));
$dateI = trim($request->get('dateI'));
$dateO = trim($request->get('dateO'));
if(empty($dateI)) {
$date = new DateTime('now');
$dateI = $date->format('Y-m-01');
$dateO = $date->format('Y-m-t');
}
$studentList = $em->getRepository(Students::class)->getScoreTest($course, $dateI, $dateO);
$courses = $em->getRepository(Courses::class)->findBy([], ['id' => 'ASC']);
$listdata = $paginator->paginate(
$studentList,
$request->query->getInt('page', 1),
50
);
return $this->render('student/reportTestScore.html.twig', [
'listdata' => $listdata,
'dateI' => $dateI,
'dateO' => $dateO,
'course' => $course,
'coursesList' => $courses,
]);
}
public function reportTestsScoreExcel(Request $request) {
$em = $this->getDoctrine()->getManager();
$course = trim($request->get('course'));
$dateI = trim($request->get('dateI'));
$dateO = trim($request->get('dateO'));
if (empty($dateI)) {
$date = new DateTime('now');
$dateI = $date->format('Y-m-01');
$dateO = $date->format('Y-m-t');
}
$studentList = $em->getRepository(Students::class)->getScoreTest($course, $dateI, $dateO);
$list = $studentList->getResult();
$header = ['Nombres', 'Apellidos', 'Identificación', 'Sede', 'Curso', 'Nivel', 'F. Presentado', 'F. Revisado',
'Estado', 'Aprobación', 'Intentos', 'Reading', 'Writing', 'Listenig', 'Speaking', 'Total'];
$body = [];
foreach ($list as $score) {
$txtApproved = '';
if ($score->getStatus() == 'FINISHED') {
$txtApproved = $score->getApprovedText();
}
$body[] = [
$score->getStudent()->getNames(),
$score->getStudent()->getLastname(),
$score->getStudent()->getDocumentNumber(),
$score->getStudent()->getCampus(),
$score->getModule()->getLevel()->getCourse()->getName(),
$score->getModule()->getLevel()->getName(),
$score->getPresentedAt() ? $score->getPresentedAt()->format('Y-m-d h:i a') : '',
$score->getCheckedAt() ? $score->getCheckedAt()->format('Y-m-d h:i a') : '',
$score->getStatusText(),
$txtApproved,
$score->getAttemps(),
$score->getScoreReading(),
$score->getScoreWriting(),
$score->getScoreListening(),
$score->getScoreSpeaking(),
$score->getScore(),
];
}
$filexlsx = Utilities::generateExcelByArr($header, $body);
$fileName = "Reporte de Notas $dateI-$dateO .xlsx";
$response = new StreamedResponse(function () use ($filexlsx) {
$filexlsx->save('php://output');
});
$response->headers->set('Content-Type', 'application/vnd.ms-excel');
$response->headers->set('Content-Disposition', 'attachment;filename="' . $fileName . '"');
$response->headers->set('Cache-Control', 'max-age=0');
return $response;
}
public function downloadExcelTemplate() {
$response = new Response();
$response->headers->set('Content-type', 'application/octet-stream');
$response->headers->set('Content-Disposition', sprintf('attachment; filename="%s"', "plantilla_examenes.xlsx"));
$response->setContent(file_get_contents($this->getParameter('kernel.project_dir') . '/documentation/PlantillaExamenes.xlsx'));
$response->setStatusCode(200);
$response->headers->set('Content-Transfer-Encoding', 'binary');
$response->headers->set('Pragma', 'no-cache');
$response->headers->set('Expires', '0');
return $response;
}
}

src/Controller/StudentController.php line 40