987 lines
39 KiB
PHP
Executable File
987 lines
39 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Controller;
|
|
|
|
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\Form\FormError;
|
|
use Symfony\Component\HttpFoundation\JsonResponse;
|
|
|
|
use Symfony\Component\HttpKernel\KernelInterface;
|
|
use Symfony\Component\Filesystem\Filesystem;
|
|
use Symfony\Component\HttpFoundation\BinaryFileResponse;
|
|
use Symfony\Component\HttpFoundation\ResponseHeaderBag;
|
|
|
|
use App\Entity\Tallyday as Entity;
|
|
use App\Form\TallydayType as Form;
|
|
|
|
class TallydayController extends AbstractController
|
|
{
|
|
private $data = "tallyday";
|
|
private $route = "app_tallyday";
|
|
private $render = "Tallyday/";
|
|
private $entity = "App:Tallyday";
|
|
|
|
private $appKernel;
|
|
private $knpSnappy;
|
|
|
|
public function __construct(KernelInterface $appKernel,\Knp\Snappy\Pdf $knpSnappy)
|
|
{
|
|
$this->appKernel = $appKernel;
|
|
$this->knpSnappy = $knpSnappy;
|
|
}
|
|
|
|
public function tallyday(Request $request)
|
|
{
|
|
$datenow=new \DateTime();
|
|
$em = $this->getDoctrine()->getManager();
|
|
$datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$datenow);
|
|
|
|
// Calcul du temps de la journée
|
|
$e = new \DateTime('00:00');
|
|
$f = clone $e;
|
|
foreach($datas as $data) {
|
|
$e->add($data->getTimeday());
|
|
}
|
|
$interval = $f->diff($e);
|
|
$timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
|
|
return $this->render('Tallyday/tallyday.html.twig',[
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => true,
|
|
"maxwidth" => true,
|
|
$this->data."s" => $datas,
|
|
"timeday" => $timeday,
|
|
"capitaltime" => $em->getRepository("App:Tallyday")->getCapitaltime($this->getUser()),
|
|
"message" => $request->get("message"),
|
|
]);
|
|
}
|
|
|
|
|
|
public function usertallydays(Request $request) {
|
|
if($request->get("week")) {
|
|
$weeknow=new \DateTime($request->get("week"));
|
|
$weeknow->modify('monday this week');
|
|
$weeknext=clone $weeknow;
|
|
$weeknext->modify('monday next week');
|
|
$weekprev=clone $weeknow;
|
|
$weekprev->modify('monday previous week');
|
|
}
|
|
else {
|
|
$weeknow=new \DateTime('monday this week');
|
|
$weeknext=new \DateTime('monday next week');
|
|
$weekprev=new \DateTime('monday previous week');
|
|
}
|
|
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
$dates=[];
|
|
$dateend=clone $weeknow;
|
|
$dateend->modify("sunday this week");
|
|
|
|
$eweek = new \DateTime('00:00');
|
|
$fweek = clone $eweek;
|
|
|
|
$datenow=clone $weeknow;
|
|
while($datenow<=$dateend) {
|
|
$eday = new \DateTime('00:00');
|
|
$fday = clone $eday;
|
|
|
|
$isvalideuser=false;
|
|
$isvalidemaster=false;
|
|
|
|
$datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$datenow);
|
|
foreach($datas as $data) {
|
|
$eweek->add($data->getTimeday());
|
|
$eday->add($data->getTimeday());
|
|
$isvalideuser=$data->getValidateuser();
|
|
$isvalidemaster=$data->getValidatemaster();
|
|
}
|
|
|
|
$interval = $fday->diff($eday);
|
|
$timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
array_push($dates,["date"=>clone $datenow,"isvalideuser"=>$isvalideuser,"isvalidemaster"=>$isvalidemaster,"timeday"=>$timeday,"tallydays"=>$datas]);
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
|
|
$interval = $fweek->diff($eweek);
|
|
$timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
// récupérer la premier validation master
|
|
$firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
|
|
|
|
return $this->render('Tallyday/user.html.twig',[
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => false,
|
|
"maxwidth" => true,
|
|
"dates" => $dates,
|
|
"week" => $weeknow,
|
|
"weeknext" => $weeknext,
|
|
"weekprev" => $weekprev,
|
|
"timeweek" => $timeweek,
|
|
"firstvalidate" => $firstvalidate,
|
|
"capitaltime" => $em->getRepository("App:Tallyday")->getCapitaltime($this->getUser()),
|
|
"message" => $request->get("message"),
|
|
]);
|
|
}
|
|
|
|
public function mastertallydays(Request $request) {
|
|
$dates=[];
|
|
|
|
// Pour l'ensemble des utlisateurs
|
|
$em = $this->getDoctrine()->getManager();
|
|
$users = $em->getRepository("App:User")->findBy([],["firstname"=>"ASC","lastname"=>"ASC"]);
|
|
foreach($users as $user) {
|
|
if($user->hasRole("ROLE_USER")) {
|
|
$dates[$user->getId()] = [
|
|
"id"=>$user->getId(),
|
|
"avatar"=>$user->getAvatar(),
|
|
"displayname"=>$user->getDisplayname(),
|
|
"capitaltime"=>$em->getRepository("App:Tallyday")->getCapitaltime($user),
|
|
"validates"=>[],
|
|
"notvalidates"=>[],
|
|
];
|
|
|
|
// On recherche le dernier pointage validé
|
|
$tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"DESC"]);
|
|
unset($datenow);
|
|
if($tallyday) {
|
|
$datenow=clone $tallyday->getDateof();
|
|
$datenow=$datenow->modify("monday this week");
|
|
$dateend=clone $tallyday->getDateof();
|
|
$dateend->modify("sunday this week");
|
|
|
|
$eweek = new \DateTime('00:00');
|
|
$fweek = clone $eweek;
|
|
|
|
while($datenow<=$dateend) {
|
|
$tallydays= $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
|
|
$eday = new \DateTime('00:00');
|
|
$fday = clone $eday;
|
|
foreach($tallydays as $tallyday) {
|
|
$eweek->add($tallyday->getTimeday());
|
|
$eday->add($tallyday->getTimeday());
|
|
}
|
|
$interval = $fday->diff($eday);
|
|
$timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
$tmp= [
|
|
"dateof"=>clone $datenow,
|
|
"tallydays"=>$tallydays,
|
|
"timeweek"=>"00:00",
|
|
"timeday"=>$timeday,
|
|
];
|
|
|
|
array_push($dates[$user->getId()]["validates"],$tmp);
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
|
|
$interval = $fweek->diff($eweek);
|
|
$timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
$dates[$user->getId()]["validates"][0]["timeweek"]=$timeweek;
|
|
}
|
|
|
|
// On recherche le premier pointage non validé
|
|
$tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>false],["dateof"=>"ASC"]);
|
|
if($tallyday)
|
|
$datenow= $tallyday->getDateof();
|
|
else
|
|
$datenow=new \DateTime("now");
|
|
|
|
|
|
$datenow->modify("monday this week");
|
|
$dateend=new \DateTime("now");
|
|
$dateend->add(new \DateInterval("P14D"));
|
|
$dateend->modify("next sunday");
|
|
|
|
$i=0;
|
|
while($datenow<=$dateend) {
|
|
if($datenow->format('w')==1) {
|
|
$eweek = new \DateTime('00:00');
|
|
$fweek = clone $eweek;
|
|
$entrymonday=$i;
|
|
}
|
|
|
|
$tallydays= $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
|
|
$eday = new \DateTime('00:00');
|
|
$fday = clone $eday;
|
|
foreach($tallydays as $tallyday) {
|
|
$eweek->add($tallyday->getTimeday());
|
|
$eday->add($tallyday->getTimeday());
|
|
}
|
|
$interval = $fday->diff($eday);
|
|
$timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
$tmp= [
|
|
"dateof"=>clone $datenow,
|
|
"tallydays"=>$tallydays,
|
|
"timeweek"=>"00:00",
|
|
"timeday"=>$timeday,
|
|
];
|
|
|
|
array_push($dates[$user->getId()]["notvalidates"],$tmp);
|
|
|
|
if($datenow->format('w')==0) {
|
|
$interval = $fweek->diff($eweek);
|
|
$timeweek = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
$dates[$user->getId()]["notvalidates"][$entrymonday]["timeweek"]=$timeweek;
|
|
}
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
$i++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return $this->render('Tallyday/master.html.twig',[
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => false,
|
|
"maxwidth" => false,
|
|
"dates" => $dates,
|
|
"message" => $request->get("message"),
|
|
]);
|
|
}
|
|
|
|
public function usersubmit($dateof,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$dateof=new \DateTime($dateof);
|
|
|
|
// Pas normal = on ne peut créer une donnée sur une journée déjà validé par l'utilisateur
|
|
$isvalideuser= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validateuser"=>true]);
|
|
if($isvalideuser) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
// Pas normal = on ne peut créer une donnée sur une journée déjà validé par master
|
|
$isvalidemaster= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validatemaster"=>true]);
|
|
if($isvalidemaster) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
return $this->submit($this->getUser(),$dateof,"user",$request);
|
|
}
|
|
|
|
public function mastersubmit($userid,$dateof,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$dateof=new \DateTime($dateof);
|
|
|
|
// Pas normal = on ne peut créer un enregistrement sur un utilisateur inexistant
|
|
$user = $em->getRepository("App:User")->find($userid);
|
|
if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
// Pas normal = on ne peut créer une donnée sur une journée déjà validé par master
|
|
$isvalidemaster= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$dateof,"validatemaster"=>true]);
|
|
if($isvalidemaster) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
return $this->submit($user,$dateof,"master",$request);
|
|
}
|
|
|
|
public function submit($user,$dateof,$access,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// Récupérer la premier validation master
|
|
$firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"ASC"]);
|
|
|
|
// Pas normal = on ne peut créer une donnée antérieur à la première validation master
|
|
if($firstvalidate && $firstvalidate->getDateof() > $dateof) return $this->redirectToRoute("app_tallyday_".$mode."list");
|
|
|
|
$data = new Entity();
|
|
$data->setUser($user);
|
|
$data->setDateof($dateof);
|
|
$data->setValidateuser(false);
|
|
$data->setValidatemaster(false);
|
|
$data->setIsbreakday(false);
|
|
|
|
// Création du formulaire
|
|
$form = $this->createForm(Form::class,$data);
|
|
|
|
// Récupération des data du formulaire
|
|
$form->handleRequest($request);
|
|
|
|
// Set le jour au différent horaire
|
|
if($data->getDatestart()) {
|
|
$datestart= clone $data->getDateof();
|
|
$datestart->setTime($data->getDatestart()->format("H"),$data->getDatestart()->format("i"));
|
|
$data->setDatestart($datestart);
|
|
} else $data->setDatestart(null);
|
|
|
|
if($data->getDateend()) {
|
|
$dateend= clone $data->getDateof();
|
|
$dateend->setTime($data->getDateend()->format("H"),$data->getDateend()->format("i"));
|
|
$data->setDateend($dateend);
|
|
} else $data->setDateend(null);
|
|
|
|
// Sur erreur
|
|
$this->getErrorForm($data->getId(),$form,$request,$data,"update");
|
|
|
|
// Sur validation
|
|
if ($form->get('submit')->isClicked() && $form->isValid()) {
|
|
$data = $form->getData();
|
|
|
|
|
|
$em->persist($data);
|
|
$em->flush();
|
|
|
|
// Retour à la liste
|
|
if($access=="master")
|
|
return $this->redirectToRoute("app_tallyday_masterlist");
|
|
else
|
|
return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
|
|
}
|
|
|
|
// Affichage du formulaire
|
|
return $this->render($this->render.'edit.html.twig', [
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => true,
|
|
"maxwidth" => true,
|
|
$this->data => $data,
|
|
"week" => $request->get("week"),
|
|
"access" => $access,
|
|
"mode" => "submit",
|
|
'form' => $form->createView()
|
|
]);
|
|
}
|
|
|
|
public function userupdate($id,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$data = $em->getRepository($this->entity)->find($id);
|
|
|
|
// Pas normal = on ne peut modifier un enregistrement inexistant
|
|
if(!$data) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
// Pas normal = un user ne peut modifier que ses propres données
|
|
if($data->getUser()!=$this->getUser()) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
// Pas normal = un user ne peut modifier une données validées
|
|
if($data->getValidateuser()||$data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
return $this->update($data,"user",$request);
|
|
}
|
|
|
|
public function masterupdate($id,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$data = $em->getRepository($this->entity)->find($id);
|
|
|
|
// Pas normal = on ne peut modifier un enregistrement inexistant
|
|
if(!$data) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
// Pas normal = un master ne peut modifier une données validées
|
|
if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
return $this->update($data,"master",$request);
|
|
}
|
|
|
|
public function update($data,$access,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// Récupérer la premier validation master
|
|
$firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$data->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
|
|
|
|
// Pas normal = on ne peut modifier une donnée antérieur à la première validation master
|
|
if($firstvalidate && $firstvalidate->getDateof() > $data->getDateof()) return $this->redirectToRoute("app_tallyday_".$mode."list");
|
|
|
|
// Création du formulaire
|
|
$form = $this->createForm(Form::class,$data);
|
|
|
|
// Récupération des data du formulaire
|
|
$form->handleRequest($request);
|
|
|
|
// Set le jour au différent horaire
|
|
if($data->getDatestart()) {
|
|
$datestart= clone $data->getDateof();
|
|
$datestart->setTime($data->getDatestart()->format("H"),$data->getDatestart()->format("i"));
|
|
$data->setDatestart($datestart);
|
|
} else $data->setDatestart(null);
|
|
|
|
if($data->getDateend()) {
|
|
$dateend= clone $data->getDateof();
|
|
$dateend->setTime($data->getDateend()->format("H"),$data->getDateend()->format("i"));
|
|
$data->setDateend($dateend);
|
|
} else $data->setDateend(null);
|
|
|
|
// Sur erreur
|
|
$this->getErrorForm($data->getId(),$form,$request,$data,"update");
|
|
|
|
// Sur validation
|
|
if ($form->get('submit')->isClicked() && $form->isValid()) {
|
|
$data = $form->getData();
|
|
|
|
|
|
$em->persist($data);
|
|
$em->flush();
|
|
|
|
// Retour à la liste
|
|
if($access=="master")
|
|
return $this->redirectToRoute("app_tallyday_masterlist");
|
|
else
|
|
return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
|
|
}
|
|
|
|
// Affichage du formulaire
|
|
return $this->render($this->render.'edit.html.twig', [
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => true,
|
|
"maxwidth" => true,
|
|
$this->data => $data,
|
|
"week" => $request->get("week"),
|
|
"access" => $access,
|
|
"mode" => "update",
|
|
'form' => $form->createView()
|
|
]);
|
|
}
|
|
|
|
|
|
public function userdelete($id,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$data = $em->getRepository($this->entity)->find($id);
|
|
|
|
// Pas normal = on ne peut supprimer un enregistrement inexistant
|
|
if(!$data) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
// Pas normal = un user ne peut supprimer que ses propres données
|
|
if($data->getUser()!=$this->getUser()) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
// Pas normal = un user ne peut supprimer une données validées
|
|
if($data->getValidateuser()||$data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_userlist");
|
|
|
|
return $this->delete($data,"user",$request);
|
|
}
|
|
|
|
public function masterdelete($id,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
$data = $em->getRepository($this->entity)->find($id);
|
|
|
|
// Pas normal = on ne peut supprimer un enregistrement inexistant
|
|
if(!$data) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
// Pas normal = un master ne peut modifier une données validées
|
|
if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
return $this->delete($data,"master",$request);
|
|
}
|
|
|
|
public function delete($data,$access,Request $request)
|
|
{
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// Récupérer la premier validation master
|
|
$firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$data->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
|
|
|
|
// Pas normal = on ne peut supprimer une donnée antérieur à la première validation master
|
|
if($firstvalidate && $firstvalidate->getDateof() > $data->getDateof()) return $this->redirectToRoute("app_tallyday_".$mode."list");
|
|
|
|
$em->remove($data);
|
|
$em->flush();
|
|
|
|
// Retour à la liste
|
|
if($access=="master")
|
|
return $this->redirectToRoute("app_tallyday_masterlist");
|
|
else
|
|
return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
|
|
|
|
}
|
|
|
|
public function uservalidate($dateof, Request $request) {
|
|
$em = $this->getDoctrine()->getManager();
|
|
$dateof=new \DateTime($dateof);
|
|
|
|
// récupérer la premier validation master
|
|
$firstvalidate= $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"validatemaster"=>true],["dateof"=>"ASC"]);
|
|
|
|
// Pas normal
|
|
if($firstvalidate && $firstvalidate->getDateof() > $dateof) return $this->redirectToRoute("app_tallyday");
|
|
|
|
// Récupérer les créneaux
|
|
$datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$dateof);
|
|
|
|
// Si aucun enregistrement on initialise le pointage sur la journée à vide
|
|
if(!$datas) {
|
|
$data = new Entity();
|
|
$data->setUser($this->getUser());
|
|
|
|
$data->setDateof($dateof);
|
|
$data->setValidateuser(true);
|
|
$data->setValidatemaster(false);
|
|
$data->setIsbreakday(false);
|
|
|
|
$em->persist($data);
|
|
$em->flush();
|
|
}
|
|
|
|
foreach($datas as $data) {
|
|
if($data->getDatestart()&&!$data->getDateend()) {
|
|
if($request->get("from")=="list")
|
|
return $this->redirectToRoute("app_tallyday_userlist",["message"=>"Impossible de valider, il vous manque des dates de fin"]);
|
|
else
|
|
return $this->redirectToRoute("app_tallyday",["message"=>"Impossible de valider, il vous manque des dates de fin"]);
|
|
}
|
|
|
|
// Validation
|
|
$data->setValidateuser(true);
|
|
$em->persist($data);
|
|
}
|
|
|
|
$em->flush();
|
|
|
|
if($request->get("from")=="list")
|
|
return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
|
|
else
|
|
return $this->redirectToRoute("app_tallyday");
|
|
}
|
|
|
|
public function mastervalidate($userid, $weekday, Request $request) {
|
|
$em = $this->getDoctrine()->getManager();
|
|
$user=$em->getRepository("App:User")->find($userid);
|
|
|
|
// Pas normal
|
|
if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
// Premiere passe de controle
|
|
$datenow=new \DateTime($weekday);
|
|
$dateend=clone $datenow;
|
|
$dateend->modify("next sunday");
|
|
|
|
while($datenow<=$dateend) {
|
|
$datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
|
|
// Si aucun enregistrement on initialise le pointage sur la journée à vide
|
|
if(!$datas) {
|
|
$data = new Entity();
|
|
$data->setUser($user);
|
|
|
|
$data->setDateof($datenow);
|
|
$data->setValidateuser(false);
|
|
$data->setValidatemaster(true);
|
|
$data->setIsbreakday(false);
|
|
|
|
$em->persist($data);
|
|
$em->flush();
|
|
}
|
|
|
|
foreach($datas as $data) {
|
|
if($data->getDatestart()&&!$data->getDateend()) {
|
|
return new JsonResponse([
|
|
'success' => false,
|
|
'message' => "Impossible de valider, il manque des dates de fin",
|
|
]);
|
|
}
|
|
}
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
|
|
// Seconde passe de validation
|
|
$datenow=new \DateTime($weekday);
|
|
$dateend=clone $datenow;
|
|
$dateend->modify("next sunday");
|
|
|
|
while($datenow<=$dateend) {
|
|
$datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
|
|
// Validation
|
|
foreach($datas as $data) {
|
|
$data->setValidatemaster(true);
|
|
$em->persist($data);
|
|
}
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
|
|
$em->flush();
|
|
return new JsonResponse(['success' => true]);
|
|
}
|
|
|
|
public function userdevalidate($dateof, Request $request) {
|
|
$em = $this->getDoctrine()->getManager();
|
|
$dateof=new \DateTime($dateof);
|
|
|
|
$em = $this->getDoctrine()->getManager();
|
|
$datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),$dateof);
|
|
|
|
// Pas normal = on ne peut pas dévalider qqchose qui n'existe pas
|
|
if(!$datas) return $this->redirectToRoute("app_tallyday");
|
|
|
|
// Pas normal = l'utilisateur ne peut pas dévalider une validation master
|
|
foreach($datas as $data) {
|
|
if($data->getValidatemaster()) return $this->redirectToRoute("app_tallyday");
|
|
}
|
|
|
|
foreach($datas as $data) {
|
|
if($data->getDatestart()&&$data->getDateend()) {
|
|
// Dévalidation
|
|
$data->setValidateuser(false);
|
|
$em->persist($data);
|
|
$em->flush();
|
|
}
|
|
else {
|
|
$em->remove($data);
|
|
$em->flush();
|
|
}
|
|
}
|
|
|
|
if($request->get("from")=="list")
|
|
return $this->redirectToRoute("app_tallyday_userlist",["week"=>$request->get("week")]);
|
|
else
|
|
return $this->redirectToRoute("app_tallyday");
|
|
}
|
|
|
|
public function masterdevalidate($userid, $weekday, Request $request) {
|
|
$em = $this->getDoctrine()->getManager();
|
|
$user=$em->getRepository("App:User")->find($userid);
|
|
|
|
|
|
// Pas normal = on ne peut dévalider un utilisateur qui n'existe pas
|
|
if(!$user) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
// On recherche le dernier pointage validé
|
|
$tallyday=$em->getRepository(("App:Tallyday"))->findOneBy(["user"=>$user,"validatemaster"=>true],["dateof"=>"DESC"]);
|
|
|
|
// Pas normal = on ne peut dévalider qq qui n'existe pas
|
|
if(!$tallyday) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
$datenow=new \DateTime($weekday);
|
|
$dateend=clone $datenow;
|
|
$dateend->modify("next sunday");
|
|
|
|
// Pas normal = on peut dévalider que la dernière validation
|
|
if($datenow!=$tallyday->getDateof()->modify("previous monday")) return $this->redirectToRoute("app_tallyday_masterlist");
|
|
|
|
while($datenow<=$dateend) {
|
|
$datas= $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
foreach($datas as $data) {
|
|
if($data->getDatestart()&&$data->getDateend()) {
|
|
// Dévalidation
|
|
$data->setValidatemaster(false);
|
|
$em->persist($data);
|
|
$em->flush();
|
|
}
|
|
else {
|
|
$em->remove($data);
|
|
$em->flush();
|
|
}
|
|
}
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
$em->flush();
|
|
|
|
return $this->redirectToRoute("app_tallyday_masterlist");
|
|
}
|
|
|
|
public function mastermonth($monthof, Request $request) {
|
|
// On calcul le nombre de jour ouvrable dans le mois
|
|
$datenow=new \DateTime($monthof."01");
|
|
$dateend=clone $datenow;
|
|
$dateend->modify("last day of this month");
|
|
|
|
$nbopendays=0;
|
|
while ($datenow <= $dateend) {
|
|
// jour différent de samedi et dimanche
|
|
if($datenow->format("w")!=0&&$datenow->format("w")!=6)
|
|
$nbopendays++;
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
$timetowork=($nbopendays*7).":00";
|
|
|
|
// Pour l'ensemble des utlisateurs
|
|
$em = $this->getDoctrine()->getManager();
|
|
$users = $em->getRepository("App:User")->findBy([],["firstname"=>"ASC","lastname"=>"ASC"]);
|
|
$dates=[];
|
|
|
|
foreach($users as $user) {
|
|
if($user->hasRole("ROLE_USER")) {
|
|
$dates[$user->getId()] = [
|
|
"id"=>$user->getId(),
|
|
"avatar"=>$user->getAvatar(),
|
|
"displayname"=>$user->getDisplayname(),
|
|
"timemonth"=>"00:00",
|
|
"validates"=>[],
|
|
];
|
|
|
|
$datenow=new \DateTime($monthof."01");
|
|
$dateend=clone $datenow;
|
|
$dateend->modify("last day of this month");
|
|
|
|
$nextmonth=clone $datenow;
|
|
$nextmonth->modify("first day of next month");
|
|
|
|
$prevmonth=clone $datenow;
|
|
$prevmonth->modify("first day of previous month");
|
|
|
|
$emonth = new \DateTime('00:00');
|
|
$fmonth = clone $emonth;
|
|
|
|
while($datenow<=$dateend) {
|
|
$eday = new \DateTime('00:00');
|
|
$fday = clone $eday;
|
|
|
|
$datas = $em->getRepository($this->entity)->findTallyday($user,$datenow);
|
|
foreach($datas as $data) {
|
|
$emonth->add($data->getTimeday());
|
|
$eday->add($data->getTimeday());
|
|
}
|
|
|
|
$interval = $fday->diff($eday);
|
|
$timeday = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
array_push($dates[$user->getId()]["validates"],[
|
|
"dateof"=>clone $datenow,
|
|
"timeday"=>$timeday,
|
|
"tallydays"=>$datas
|
|
]);
|
|
|
|
$datenow->add(new \DateInterval('P1D'));
|
|
}
|
|
|
|
$interval = $fmonth->diff($emonth);
|
|
$timemonth = (($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
$dates[$user->getId()]["timemonth"]=$timemonth;
|
|
}
|
|
}
|
|
|
|
if($request->get('type')=="pdf") {
|
|
$rootdir = $this->appKernel->getProjectDir()."/uploads";
|
|
$filename="Rapport-".$dateend->format("Ym").".pdf";
|
|
$fileloc=$rootdir."/".$filename;
|
|
|
|
$fs = new Filesystem();
|
|
$fs->remove(array($fileloc));
|
|
|
|
$render = $this->renderView('Tallyday/month.html.twig',[
|
|
"useheader" => false,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => false,
|
|
"maxwidth" => false,
|
|
"monthof" => $dateend,
|
|
"nextmonth" => $nextmonth->format("Ym"),
|
|
"prevmonth" => $prevmonth->format("Ym"),
|
|
"timetowork" => $timetowork,
|
|
"dates" => $dates,
|
|
"fgprint" => true,
|
|
"message" => $request->get("message"),
|
|
]);
|
|
|
|
$appWeburl=$this->getParameter("appWeburl");
|
|
$appAlias=$this->getParameter("appAlias");
|
|
|
|
$render=str_replace("/$appAlias/","https://$appWeburl/$appAlias/",$render);
|
|
//dump($render);
|
|
|
|
$this->knpSnappy->generateFromHtml($render,$fileloc);
|
|
return $this->file($fileloc);
|
|
}
|
|
else {
|
|
return $this->render('Tallyday/month.html.twig',[
|
|
"useheader" => true,
|
|
"usesidebar" => false,
|
|
"usemonocolor" => false,
|
|
"maxwidth" => false,
|
|
"monthof" => $dateend,
|
|
"nextmonth" => $nextmonth->format("Ym"),
|
|
"prevmonth" => $prevmonth->format("Ym"),
|
|
"timetowork" => $timetowork,
|
|
"dates" => $dates,
|
|
"fgprint" => false,
|
|
"message" => $request->get("message"),
|
|
]);
|
|
}
|
|
}
|
|
|
|
public function masterexport() {
|
|
$em = $this->getDoctrine()->getManager();
|
|
$rootdir = $this->appKernel->getProjectDir()."/uploads";
|
|
|
|
$dateof=new \DateTime();
|
|
$filename="Export-".$dateof->format("Ymd").".csv";
|
|
|
|
$fs = new Filesystem();
|
|
$fs->mkdir($rootdir);
|
|
$csvh = fopen($rootdir."/".$filename, 'w');
|
|
$d = ';'; // this is the default but i like to be explicit
|
|
$e = '"'; // this is the default but i like to be explicit
|
|
|
|
$csvh = fopen($rootdir."/".$filename, 'w');
|
|
|
|
$csv=["Utilisateur",utf8_decode("Début"),"Fin","Temps",utf8_decode("Libellé")];
|
|
fputcsv($csvh, $csv, $d, $e);
|
|
|
|
$datas = $em->getRepository($this->entity)->findBy([],["user"=>"ASC","dateof"=>"ASC"]);
|
|
foreach($datas as $data) {
|
|
if($data->getDatestart() || $data->getDateend()) {
|
|
$csv=[
|
|
utf8_decode($data->getUser()->getDisplayname()),
|
|
$data->getDatestart()->format("d/m/Y H:i"),
|
|
($data->getDateend()?$data->getDateend()->format("d/m/Y H:i"):""),
|
|
$data->getTimedayformatted(),
|
|
utf8_decode(($data->getName()?$data->getName():""))
|
|
|
|
];
|
|
fputcsv($csvh, $csv, $d, $e);
|
|
}
|
|
}
|
|
|
|
$response = new BinaryFileResponse($rootdir."/".$filename);
|
|
$response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT);
|
|
return $response;
|
|
}
|
|
|
|
public function start() {
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
$datenow=new \DateTime("now");
|
|
$datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
|
|
|
|
|
|
$data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"datestart"=>$datenow]);
|
|
if(!$data) {
|
|
$data = new Entity();
|
|
$data->setDateof(new \DateTime("now"));
|
|
$data->setUser($this->getUser());
|
|
$data->setValidateuser(false);
|
|
$data->setValidatemaster(false);
|
|
$data->setIsbreakday(false);
|
|
$data->setDatestart($datenow);
|
|
}
|
|
|
|
// Pas normal = Vérifier qu'il n'y ait pas de chevauchement de créneaux
|
|
if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
|
|
return $this->redirectToRoute("app_tallyday",["message"=>"Incohérance dans votre pointage"]);
|
|
}
|
|
|
|
$em->persist($data);
|
|
$em->flush();
|
|
|
|
return $this->redirectToRoute("app_tallyday");
|
|
|
|
}
|
|
|
|
public function end() {
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// On recherche le dernier pointage de la journée
|
|
$datenow=new \DateTime("now");
|
|
$datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
|
|
$data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$datenow],["datestart"=>"DESC"]);
|
|
|
|
// Pas normal = on devrait avoir au minimum un tally si on veut faire un pointage de fin
|
|
if(!$data)
|
|
return $this->redirectToRoute("app_tallyday");
|
|
|
|
// Pas normal = si on pointe la fin il faut forcement que le dernier pointage soit sans date de fin et avec une date de début
|
|
if($data->getDateend()||!$data->getDatestart())
|
|
return $this->redirectToRoute("app_tallyday");
|
|
|
|
// Pas normal = Vérifier qu'il n'y ait pas de chevauchement de créneaux
|
|
if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
|
|
return $this->redirectToRoute("app_tallyday",["message"=>"Incohérance dans votre pointage"]);
|
|
}
|
|
|
|
$data->setDateend($datenow);
|
|
$em->persist($data);
|
|
$em->flush();
|
|
|
|
return $this->redirectToRoute("app_tallyday");
|
|
}
|
|
|
|
public function userrecalcul() {
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
// On recherche le dernier pointage de la journée
|
|
$datenow=new \DateTime("now");
|
|
$datenow->setTime ( $datenow->format("H"), $datenow->format("i"), 0 );
|
|
$datas = $em->getRepository($this->entity)->findTallyday($this->getUser(),clone $datenow);
|
|
|
|
// Cumul des temps de la journée
|
|
$e = new \DateTime('00:00');
|
|
$f = clone $e;
|
|
foreach($datas as $data) {
|
|
$e->add($data->getTimeday());
|
|
}
|
|
|
|
// On recherche le dernier pointage de la journée non terminé et on simule le créneau avec la date du moment
|
|
$data = $em->getRepository($this->entity)->findOneBy(["user"=>$this->getUser(),"dateof"=>$datenow],["datestart"=>"DESC"]);
|
|
if($data&&$data->getDatestart()&&!$data->getDateend()) {
|
|
$interval2 = $datenow->diff($data->getDatestart());
|
|
$e->add($interval2);
|
|
}
|
|
|
|
// Calcul de temps global de la journée = réel + simulé
|
|
$interval = $e->diff($f);
|
|
$timeday = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
// On récupère le capital
|
|
$capital=$em->getRepository("App:Tallyday")->getCapitaltimeinterval($this->getUser());
|
|
$e = new \DateTime('00:00');
|
|
|
|
|
|
// Si la journée n'est finalisé on ajoute le créneau simulé
|
|
if($data&&$data->getDatestart()&&!$data->getDateend()) {
|
|
$f = new \DateTime('00:00');
|
|
$f->add($interval);
|
|
$f->sub(new \DateInterval('PT7H'));
|
|
$f->add($capital);
|
|
|
|
$interval = $e->diff($f);
|
|
$newcapital = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
|
|
}
|
|
// Si la journée n'est pas encore validé : on ajoute la journée à la simulation
|
|
else if($data && (!$data->getValidateuser()||!$data->getValidateuser())) {
|
|
$interval=$em->getRepository("App:Tallyday")->getCapitaltimeinterval($this->getUser(),true);
|
|
$newcapital = $interval->format("%R").(($interval->days*24) + $interval->h).":".sprintf("%02s",$interval->i);
|
|
}
|
|
|
|
|
|
return new JsonResponse([
|
|
'success' => true,
|
|
'tosimulatetime' => ($data&&$data->getDatestart()&&!$data->getDateend()),
|
|
'timeday' => $timeday,
|
|
'tosimulatecapital' => ($data&&(!$data->getValidateuser()||!$data->getValidateuser())),
|
|
'capital' => $newcapital,
|
|
]);
|
|
}
|
|
|
|
|
|
protected function getErrorForm($id,$form,$request,$data,$mode) {
|
|
$em = $this->getDoctrine()->getManager();
|
|
|
|
if ($form->get('submit')->isClicked()) {
|
|
// date début < date fin
|
|
if($data->getDatestart()&&$data->getDateend()) {
|
|
if($data->getDatestart()>$data->getDateend())
|
|
$form->addError(new FormError("Date de début de matin doit être inférieure à la date de fin de matin"));
|
|
}
|
|
|
|
// Vérifier qu'il n'y ait pas de chevauchement de créneaux
|
|
if(!$em->getRepository($this->entity)->vefifTallytime($data)) {
|
|
$form->addError(new FormError("Votre créneau est incohérant par rapport aux autre créneaux"));
|
|
}
|
|
}
|
|
|
|
if ($form->get('submit')->isClicked() && !$form->isValid()) {
|
|
$this->get('session')->getFlashBag()->clear();
|
|
|
|
$errors = $form->getErrors();
|
|
foreach( $errors as $error ) {
|
|
$request->getSession()->getFlashBag()->add("error", $error->getMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|