<?php
namespace App\Controller;
use App\Entity\ActionPlan;
use App\Entity\Activity;
use App\Entity\bilan\Entity;
use App\Entity\Comments;
use App\Entity\Domain;
use App\Entity\Indicator;
use App\Entity\IndicatorValues;
use App\Entity\Processus;
use App\Entity\SelectedOption;
use App\Enum\CalculModeEnum;
use App\Enum\TypeEnum;
use App\Form\IndicatorType;
use App\Repository\IndicatorRepository;
use App\Repository\IndicatorValuesRepository;
use App\Security\ProcessusVoter;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use App\Utils\Utility;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Inflector\Inflector;
use Symfony\Component\Validator\Constraints\IsNull;
/**
* @Route("/indicator")
*/
class IndicatorController extends AbstractController
{
/**
* @Route("/", name="indicator_index", methods={"GET"})
*/
public function index(): Response
{
$indicators = $this->getDoctrine()
->getRepository(Indicator::class)
->findAll();
return $this->render('indicator/index.html.twig', [
'indicators' => $indicators,
]);
}
/**
* @Route("/new", name="indicator_new", methods={"GET","POST"})
*/
public function new(Request $request): Response
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CONFIGURATION_CRUD);
$indicator = new Indicator();
/* generate ref indicator */
$lastIdIndicator=0;
$lastIndicator = $this->getDoctrine()->getRepository(Indicator::class)->findOneBy([], ['id' => 'desc']);
if(is_object($lastIndicator))
{
$lastIdIndicator = $lastIndicator->getId();
}
$utility = new Utility;
$refIndicator = $utility->generateRef($lastIdIndicator,Indicator::PREFIX);
$indicator->setRef($refIndicator);
$options=[];
$processus_id = $request->query->get('processus_id');
if($processus_id)
{
$processus = $this->getDoctrine()->getRepository(Processus::class)->find($processus_id);
$indicator->setProcessus($processus);
$options['processus_disabled']=true;
}
$hasActionPlan = $request->query->get('actionplan');
$indicator->setStatus(Indicator::STATUS_VALIDATED);
$indicator->setType(Indicator::TYPE_SURVEILLANCE);
if($hasActionPlan) {
$options['activity_disabled']=true;
$indicator->setStatus(Indicator::STATUS_DRAFT);
$indicator->setType(Indicator::TYPE_OBJECTIF);
}
$all_processus = $this->getDoctrine()->getRepository(Processus::class)->findAll();
$all_processus = new ArrayCollection($all_processus);
//$all_processus->removeElement($processus);
$all_processus_value='';
foreach($all_processus as $proc)
{
$all_processus_value.= $proc->getId();
if($proc != $all_processus->last())
{
$all_processus_value.=',';
}
}
$form = $this->createForm(IndicatorType::class, $indicator,$options);
return $this->render('indicator/new.html.twig', [
'indicator' => $indicator,
'form' => $form->createView(),
'all_processus_value'=>$all_processus_value
]);
}
/**
* @Route("/SaveIndicator", name="SaveIndicator", methods={"POST"})
*/
public function saveIndicator(Request $request)
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CONFIGURATION_CRUD);
if (!$request->isXmlHttpRequest()) {
return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
}
if(isset($request->request))
{
$id = $request->request->get('indicatorId');
$title = $request->request->get('title');
$ref = $request->request->get('ref');
$unity = $request->request->get('unity');
$calculMode = $request->request->get('calculMode');
$period = $request->request->get('period');
$seuilMinAnnual = intval($request->request->get('seuilMinAnnual'));
$seuilMaxAnnual = intval($request->request->get('seuilMaxAnnual'));
$seuilMin = intval($request->request->get('seuilMin'));
$seuilMax = intval($request->request->get('seuilMax'));
$status = $request->request->get('status');
$type = $request->request->get('type');
$entity_id = $request->request->get('entity');
$entity = $this->getDoctrine()->getRepository(Entity::class)->find($entity_id);
$domain_id = $request->request->get('domain');
$domain = $this->getDoctrine()->getRepository(Domain::class)->find($domain_id);
$processus_id = $request->request->get('processus');
$processus = $this->getDoctrine()->getRepository(Processus::class)->find($processus_id);
$activity_id = $request->request->get('activity');
$activity = $this->getDoctrine()->getRepository(Activity::class)->find($activity_id);
$proc_ids = $request->request->get('proc');
//consolide part
$category=$request->request->get('category');
$indicatorA_id=$request->request->get('indicatorA');
$indicatorB_id=$request->request->get('indicatorB');
$operation=$request->request->get('operation');
$user = $this->getUser();
$edit = '0';
if(empty($id))
{
$indicator = new Indicator();
$indicator->setRef($ref);
$indicator->setType($type);
$indicator->setCreatedBy($user);
$indicator->setResponsible($user);
}
else
{
$indicator = $this->getDoctrine()->getRepository(Indicator::class)->find($id);
$edit ='1';
}
$indicator->setTitle($title);
$indicator->setUnity($unity);
$indicator->setCalculMode($calculMode);
$indicator->setPeriod($period);
$indicator->setSeuilMinAnnual($seuilMinAnnual);
$indicator->setSeuilMaxAnnual($seuilMaxAnnual);
$indicator->setSeuilMin($seuilMin);
$indicator->setSeuilMax($seuilMax);
$indicator->setProcessus($processus);
if($entity) {
$indicator->setEntity($entity);
}
if($domain) {
$indicator->setDomain($domain);
}
//if($type == Indicator::TYPE_SURVEILLANCE) {
$indicator->setActivity($activity);
//}
$indicator->setStatus($status);
$indicator->setCategory($category);
$indicator->removeAllProcessusClients();
if(!empty($proc_ids))
{
foreach($proc_ids as $element)
{
$pid_array = explode(',',$element);
foreach($pid_array as $pid)
{
if($pid == $indicator->getProcessus()->getId()) continue;
$processus_related = $this->getDoctrine()->getRepository(Processus::class)->find($pid);
$indicator->addProc($processus_related);
if($indicator->getActivity())
{
$indicator->getActivity()->addProcessusClient($processus_related);
}
}
}
$indicator->setDataOut(true);
}else
{
$indicator->setDataOut(false);
}
if($category==Indicator::CAT_CONSOLIDE)
{
$indicatorA = $this->getDoctrine()->getRepository(Indicator::class)->find($indicatorA_id);
$indicatorB = $this->getDoctrine()->getRepository(Indicator::class)->find($indicatorB_id);
$indicator->setIndicatorA($indicatorA);
$indicator->setIndicatorB($indicatorB);
$indicator->setOperation($operation);
}else {
$indicator->setIndicatorA(NULL);
$indicator->setIndicatorB(NULL);
$indicator->setOperation('');
}
if(empty($id))
{
/* initialize indicator values */
$indicatorValues = new IndicatorValues();
$indicatorValues->setYear(date('Y'));
$indicator->addIndicatorValue($indicatorValues);
}
$entityManager = $this->getDoctrine()->getManager();
if(empty($id))
{
$entityManager->persist($indicatorValues);
$entityManager->persist($indicator);
}
$entityManager->flush();
$response = array('id' => $indicator->getId(),'title'=>$title,'edit'=>$edit);
}
return new JsonResponse($response,200);
}
/**
* @Route("/{id}", name="indicator_show", methods={"GET"})
*/
public function show(Indicator $indicator,IndicatorRepository $indicatorRepository): Response
{
$utility = new Utility;
$array_indicator_values=[];
if($indicator->getCategory()==Indicator::CAT_CONSOLIDE)
{
$indicatorRepository->setConsolidatedIndicatorValues($indicator);
}
$indicatorValues= $indicator->getIndicatorValues();
$user = $this->getUser();
$selectedCalculMode="Brut";
$selectedOption = $this->getDoctrine()->getRepository(SelectedOption::class)->findOneBy(['user'=>$user,'indicator'=>$indicator]);
if($selectedOption)
{
if($selectedOption->getCalculMode())
{
$selectedCalculMode = $selectedOption->getCalculMode();
}
}
foreach($indicatorValues as $indicatorValue)
{
$array_indicator_value=[];
$color_parts_array= $utility->random_rgb_color_array();
$array_indicator_value['year']=$indicatorValue->getYear();
$array_indicator_value['fillColor']= $utility->generate_rgb_color($color_parts_array,0.2);
$array_indicator_value['color']= $utility->generate_rgb_color($color_parts_array,1);
$array_indicator_value['Jan'] = floatval($indicatorValue->getJan($selectedCalculMode));
$array_indicator_value['Feb'] = floatval($indicatorValue->getFeb($selectedCalculMode));
$array_indicator_value['Mar'] = floatval($indicatorValue->getMar($selectedCalculMode));
$array_indicator_value['Apr'] = floatval($indicatorValue->getApr($selectedCalculMode));
$array_indicator_value['Mai'] = floatval($indicatorValue->getMai($selectedCalculMode));
$array_indicator_value['Jun'] = floatval($indicatorValue->getJun($selectedCalculMode));
$array_indicator_value['Jul'] = floatval($indicatorValue->getJul($selectedCalculMode));
$array_indicator_value['Aug'] = floatval($indicatorValue->getAug($selectedCalculMode));
$array_indicator_value['Sep'] = floatval($indicatorValue->getSep($selectedCalculMode));
$array_indicator_value['Oct'] = floatval($indicatorValue->getOct($selectedCalculMode));
$array_indicator_value['Nov'] = floatval($indicatorValue->getNov($selectedCalculMode));
$array_indicator_value['December'] = floatval($indicatorValue->getDecember($selectedCalculMode));
$array_indicator_values[]=$array_indicator_value;
}
$user = $this->getUser();
$selectedOption = $this->getDoctrine()->getRepository(SelectedOption::class)->findOneBy(['user'=>$user,'indicator'=>$indicator]);
if(!$selectedOption)
{
$selectedOption = new SelectedOption();
$selectedOption->setChart('courbe');
$selectedOption->setAddedToDashboard(false);
}
return $this->render('indicator/show.html.twig', [
'indicator' => $indicator,
'array_indicator_values' => $array_indicator_values,
'menu'=>'processus',
'left_menu'=>"surveillance_performances",
'selectedOption'=>$selectedOption
]);
}
/**
* @Route("/{id}/edit", name="indicator_edit", methods={"GET","POST"})
*/
public function edit(Indicator $indicator): Response
{
$all_processus = $this->getDoctrine()->getRepository(Processus::class)->findAll();
$all_processus = new ArrayCollection($all_processus);
$all_processus->removeElement($indicator->getProcessus());
$all_processus_value='';
foreach($all_processus as $proc)
{
$all_processus_value.= $proc->getId();
if($proc != $all_processus->last())
{
$all_processus_value.=',';
}
}
$all_activity_processus_value='';
foreach($indicator->getProc() as $proc)
{
$all_activity_processus_value.= $proc->getId();
if($proc != $all_processus->last())
{
$all_activity_processus_value.=',';
}
}
$all_processus_selected=$all_processus_value == $all_activity_processus_value;
$options['category_default']=$indicator->getCategory();
if($indicator->getType()==Indicator::TYPE_OBJECTIF) {
$options['processus_disabled']=true;
$options['activity_disabled']=false;
}
$form = $this->createForm(IndicatorType::class, $indicator,$options);
return $this->render('indicator/edit.html.twig', [
'indicator' => $indicator,
'form' => $form->createView(),
'all_processus_value'=>$all_processus_value,
'all_processus_selected'=>$all_processus_selected
]);
}
/**
* @Route("/delete/{id}", name="indicator_delete", methods={"GET"})
*/
public function delete(Indicator $indicator, Request $request): Response
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CONFIGURATION_CRUD);
$entityManager = $this->getDoctrine()->getManager();
$entityManager->remove($indicator);
$entityManager->flush();
$referer = $request->headers->get('referer');
return $this->redirect($referer);
//return $this->redirectToRoute('surveillanceGlobal');
}
/**
* @Route("/delete/ajax", name="indicator_delete_ajax", methods={"GET"})
*/
public function deleteAjax(Request $request)
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CONFIGURATION_CRUD);
if (!$request->isXmlHttpRequest()) {
return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
}
$id= $request->query->get('id');
$indicator= $this->getDoctrine()->getRepository(Indicator::class)->find($id);
$entityManager = $this->getDoctrine()->getManager();
$entityManager->remove($indicator);
$entityManager->flush();
$response = array('status' =>'ok');
return new JsonResponse($response,200);
}
/**
* @Route("/surveillance/all", name="surveillance", methods={"GET"})
*/
public function surveillance(Request $request,IndicatorValuesRepository $indicatorValuesRepository): Response
{
$actionplanId= $request->query->get('actionplanId');
$processusId= $request->query->get('processusId');
$years = $indicatorValuesRepository->getYears();
return $this->render('indicator/surveillance.html.twig',[
'actionplanId'=>$actionplanId,
'processusId'=>$processusId,
'years'=>$years
]);
}
/**
* @Route("/surveillanceGlobal/all", name="surveillanceGlobal", methods={"GET"})
*/
public function surveillanceGlobal(IndicatorRepository $indicatorRepository, IndicatorValuesRepository $indicatorValuesRepository): Response
{
$em = $this->getDoctrine()->getManager();
$processus = $em->getRepository(Processus::class)->findAll();
$entities = $em->getRepository(Entity::class)->findAll();
$domains = $em->getRepository(Domain::class)->findAll();
$years = $indicatorValuesRepository->getYears();
$max_years = $indicatorRepository->getMaxYearForEachIndicator();
$current_year = date('Y');
$new_indicator_values=0;
foreach($max_years as $max_year){
if($max_year['year'] < $current_year) {
$indicator = $indicatorRepository->find($max_year['id']);
$indicatorValues = new IndicatorValues();
$indicatorValues->setYear(date('Y'));
$indicatorValues->setIndicator($indicator);
$em->persist($indicatorValues);
$new_indicator_values++;
}
}
if($new_indicator_values > 0) $em->flush();
//menu
$menu="processus";
$left_menu="surveillance_performances";
return $this->render('indicator/surveillanceGlobal.html.twig',[
'processus'=>$processus,
'entities'=>$entities,
'domains'=>$domains,
'years'=>$years,
'menu'=>$menu,
'left_menu'=>$left_menu
]);
}
/**
* @Route("/list/json", name="indicator_list", methods={"GET"})
*/
public function listIndicators(IndicatorRepository $indicatorRepository,Request $request)
{
$actionPlan='';
$actionplanId= $request->query->get('actionplanId');
if($actionplanId>0)
{
$actionPlan= $this->getDoctrine()->getRepository(ActionPlan::class)->find($actionplanId);
}
$processus='';
$processusId= $request->query->get('processusId');
if($processusId>0)
{
$processus= $this->getDoctrine()->getRepository(Processus::class)->find($processusId);
}
$user = $this->getUser();
$actionsData = $indicatorRepository->transformAll($user,$actionPlan,$processus);
return new JsonResponse($actionsData);
}
/**
* @Route("/updateIndicatorVlaues", name="update_indicatorValues", methods={"POST"})
*/
public function updateIndicatorVlaues(Request $request)
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_INDICATOR_INSERT);
if (!$request->isXmlHttpRequest()) {
return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
}
if(isset($request->request))
{
$entityManager = $this->getDoctrine()->getManager();
$id = $request->request->get('id');
$indicator_id = $request->request->get('indicator_id');
$columnName = $request->request->get('columnName');
$columnValue = $request->request->get('columnValue');
if(empty($columnValue))
{
if($columnValue != "0")
{
$columnValue=NULL;
}
}
$id =intval($id);
$indicatorValue = $entityManager->getRepository(IndicatorValues::class)->find($id);
if($columnName == "setCalculMode")
{
$indicator = $entityManager->getRepository(Indicator::class)->find($indicator_id);
$user = $this->getUser();
$selectedOption = $entityManager->getRepository(SelectedOption::class)->findOneBy(['user'=>$user,'indicator'=>$indicator]);
if($selectedOption)
{
$selectedOption->$columnName($columnValue);
}
else
{
$selectedOption = new SelectedOption();
$selectedOption->setUser($user);
$selectedOption->setIndicator($indicator);
$selectedOption->$columnName($columnValue);
$entityManager->persist($selectedOption);
}
}
else
{
$indicatorValue->$columnName($columnValue);
}
$entityManager->flush();
$response = array(
'status' => "ok"
);
}
return new JsonResponse($response,200);
}
// /**
// * @Route("/{id}/updateSelectedOptions", name="update_selected_options", methods={"POST"})
// */
// public function updateSelectedOptions(Indicator $indicator, Request $request)
// {
// if(isset($request->request)) {
// $entityManager = $this->getDoctrine()->getManager();
// $user=$this->getUser();
// $chart = $request->request->get('chart');
// $addedToDashboard = $request->request->get('in_tdb');
// $comment = $request->request->get('comment');
// $selectedOption = $entityManager->getRepository(SelectedOption::class)->findOneBy(['user'=>$user,'indicator'=>$indicator]);
// if(!$selectedOption)
// {
// $selectedOption = new SelectedOption();
// $selectedOption->setUser($user);
// $selectedOption->setIndicator($indicator);
// $selectedOption->setChart($chart);
// $selectedOption->setAddedToDashboard($addedToDashboard);
// $entityManager->persist($selectedOption);
// }else {
// $selectedOption->setChart($chart);
// $selectedOption->setAddedToDashboard($addedToDashboard);
// }
// $indicator->setComment($comment);
// $entityManager->flush();
// }
// return $this->redirectToRoute('indicator_show',['id'=>$indicator->getId()]);
// }
/**
* @Route("/{id}/updateSelectedOptions", name="update_selected_options", methods={"POST"})
*/
public function updateSelectedOptions(Indicator $indicator, Request $request)
{
if (!$request->isXmlHttpRequest()) {
return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
}
$response = array('status' => 'nok');
if(isset($request->request)) {
$entityManager = $this->getDoctrine()->getManager();
$user=$this->getUser();
$chart = $request->request->get('chart');
$addedToDashboard = $request->request->get('in_tdb');
$selectedOption = $entityManager->getRepository(SelectedOption::class)->findOneBy(['user'=>$user,'indicator'=>$indicator]);
if(!$selectedOption)
{
$selectedOption = new SelectedOption();
$selectedOption->setUser($user);
$selectedOption->setIndicator($indicator);
$selectedOption->setChart($chart);
$selectedOption->setAddedToDashboard($addedToDashboard);
$entityManager->persist($selectedOption);
}else {
$selectedOption->setChart($chart);
$selectedOption->setAddedToDashboard($addedToDashboard);
}
$entityManager->flush();
$response = array('status' => 'ok');
}
return new JsonResponse($response,200);
}
/**
* @Route("/dashboard/all", name="dashboard_indicators", methods={"GET"})
*/
public function showDashboard(IndicatorRepository $indicatorRepository, Request $request)
{
//set comment
$comment = $this->getDoctrine()->getRepository(Comments::class)->findOneBy(['object'=>'indicator']);
if(empty($comment))
{
$comment = new Comments();
$comment->setCreatedBy($this->getUser());
$comment->setObject('indicator');
$entityManager = $this->getDoctrine()->getManager();
$entityManager->persist($comment);
$entityManager->flush();
}
$utility = new Utility;
$user = $this->getUser();
$selected_processus = $request->query->get('processus');
$selectedOptions = $this->getDoctrine()->getRepository(SelectedOption::class)->findBy(['user'=>$user,'addedToDashboard'=>1]);
$indicators_chart_data=[];
$indicators = [];
foreach($selectedOptions as $selectedIndicator)
{
$indicator = $selectedIndicator->getIndicator();
if(!$indicator) continue;
if(!empty($selected_processus))
{
if(($indicator->getProcessus()->getId() != $selected_processus)) {
if(!$indicator->getProc()->exists(fn($key,$proc)=>$proc->getId()==$selected_processus) ) {
continue;
}
}
}
$id = $indicator->getId();
$indicators[]= $indicator;
if($indicator->getCategory()==Indicator::CAT_CONSOLIDE)
{
$indicatorRepository->setConsolidatedIndicatorValues($indicator);
}
$indicatorValues= $indicator->getIndicatorValues();
$indicators_chart_data[$id]['chart'] = $selectedIndicator->getChart();
foreach($indicatorValues as $indicatorValue)
{
$array_indicator_value=[];
$color_parts_array= $utility->random_rgb_color_array();
$array_indicator_value['year']=$indicatorValue->getYear();
$array_indicator_value['fillColor']= $utility->generate_rgb_color($color_parts_array,0.2);
$array_indicator_value['color']= $utility->generate_rgb_color($color_parts_array,1);
$array_indicator_value['Jan'] = floatval($indicatorValue->getJan());
$array_indicator_value['Feb'] = floatval($indicatorValue->getFeb());
$array_indicator_value['Mar'] = floatval($indicatorValue->getMar());
$array_indicator_value['Apr'] = floatval($indicatorValue->getApr());
$array_indicator_value['Mai'] = floatval($indicatorValue->getMai());
$array_indicator_value['Jun'] = floatval($indicatorValue->getJun());
$array_indicator_value['Jul'] = floatval($indicatorValue->getJul());
$array_indicator_value['Aug'] = floatval($indicatorValue->getAug());
$array_indicator_value['Sep'] = floatval($indicatorValue->getSep());
$array_indicator_value['Oct'] = floatval($indicatorValue->getOct());
$array_indicator_value['Nov'] = floatval($indicatorValue->getNov());
$array_indicator_value['December'] = floatval($indicatorValue->getDecember());
$indicators_chart_data[$id]['data'][]=$array_indicator_value;
}
}
//processus
$processus_list = $this->getDoctrine()->getRepository(Processus::class)->findAll();
return $this->render('indicator/dashboard.html.twig', [
'menu'=>'processus',
'left_menu'=>"tbd_indicators",
'indicators' => $indicators,
'indicators_chart_data' => $indicators_chart_data,
'commentDashboard'=>$comment,
'processus_list'=>$processus_list,
'selected_processus'=>$selected_processus
]);
}
/**
* @Route("/saveComment/{id}", name="save_indicator_comment", methods={"POST"})
*/
public function SaveComment(Indicator $indicator, Request $request)
{
$this->denyAccessUnlessGranted(ProcessusVoter::PROCESSUS_CONFIGURATION_CRUD);
if (!$request->isXmlHttpRequest()) {
return new JsonResponse(array('status' => 'error','message' => 'Access forbidden!'), 400);
}
if(isset($request->request))
{
$entityManager = $this->getDoctrine()->getManager();
$commentText = $request->request->get('commentText');
$indicator->setComment($commentText);
$entityManager->flush();
$response = array('status' => 'ok');
}
return new JsonResponse($response,200);
}
/**
* @Route("/processus/{id}", name="processus_indicators", methods={"GET"})
*/
public function processusIndicators(Processus $processus)
{
$activities = $this->getDoctrine()->getRepository(Activity::class)->findBy(['processus'=>$processus]);
$hasActivities = !empty($activities);
return $this->render('processus/indicators.html.twig',[
'processus'=>$processus,
'hasActivities'=>$hasActivities
]);
}
/**
* @Route("/processus/list/{id}", name="processus_indicators_json", methods={"GET"})
*/
public function processus_indicators_json(Processus $processus, IndicatorRepository $indicatorRepository)
{
$user = $this->getUser();
$all_processus = $this->getDoctrine()->getRepository(Processus::class)->findAll();
$all_processus = new ArrayCollection($all_processus);
$indicatorsData = $indicatorRepository->transformAllList($processus, $user, $all_processus);
return new JsonResponse($indicatorsData);
}
}