src/Controller/TolController.php line 121

  1. <?php
  2. namespace App\Controller;
  3. use App\Entity\Emailenv;
  4. use App\Entity\Emailenvoi;
  5. use App\Entity\Factu;
  6. use App\Entity\Param;
  7. use App\Repository\ClientRepository;
  8. use App\Repository\EmailenvoiRepository;
  9. use App\Repository\EmailenvRepository;
  10. use App\Repository\FactuRepository;
  11. use App\Repository\LieuRepository;
  12. use App\Repository\ParametreRepository;
  13. use App\Repository\ParamRepository;
  14. use App\Repository\SemainerdvRepository;
  15. use App\Repository\SemainesavRepository;
  16. use App\service\fincontrat;
  17. use App\service\JWTservice;
  18. use App\service\sendmailservice;
  19. use App\service\servicedivers;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\Response;
  23. use Symfony\Component\Routing\Annotation\Route;
  24. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  25. #[Route('/tol'name'tol_')]
  26. class TolController extends AbstractController
  27. {
  28.     #[Route('/{token}'name'index')]
  29.     public function index(string $token,JWTservice $jwt,
  30.     sendmailservice $sendmailservice,
  31.     ParametreRepository $parametreRepository,
  32.     EmailenvRepository $emailenvRepository,
  33.     SemainerdvRepository $semainerdvRepository,
  34.     SemainesavRepository $semainesavRepository,
  35.     ClientRepository $clientRepository,
  36.     LieuRepository $lieuRepository,
  37.     EntityManagerInterface $em,
  38.     EmailenvoiRepository $emailenvoiRepository,
  39.     ParamRepository $paramRepository,
  40.     FactuRepository $factuRepository
  41.     ): Response
  42.     {   $email="ko";$type="";$tache="";$message="error contacter administrateur";
  43.        // dd($token);
  44.         //   dd($token);
  45.         switch ($token) {
  46.             case 'emailun':
  47.                 if($this->getUser()->getId()!=0){
  48.                 $type="savrdv";
  49.                 $tache="email de rappel RDV SAV";
  50.                     $email="ok";
  51.             }else{$message="error inconu error";}
  52.                 break;
  53.                 case 'emailenv':
  54.                     if($this->getUser()->getId()!=0){
  55.                     $type="emailenv";
  56.                     $tache="envoi d'email";
  57.                         $email="ok";
  58.                 }else{$message="error inconu error";}
  59.                     break;
  60.                     case 'contrat':
  61.                         if($this->getUser()->getId()!=0){
  62.                         $type="contrat";
  63.                         $tache="envoi d'email";
  64.                             $email="ok";
  65.                     }else{$message="error inconu error";}
  66.                         break;
  67.                         case 'activate':
  68.                             if($this->getUser()->getId()!=0){
  69.                             $type="tolactivate";
  70.                             $tache="envoi d'email";
  71.                                 $email="ok";
  72.                         }else{$message="error inconu error";}
  73.                             break;
  74.             default:
  75.             if($jwt->isvalid($token) && $jwt->verifsigna($token,$this->getParameter('app.jwtsecret'))){
  76.             $payload$jwt->getpayload($token);
  77.               //  dd($payload);
  78.               if($payload['type']=="tolactivate"){
  79.                 $this->touactiver($sendmailservice,
  80.                 $parametreRepository,
  81.                 $emailenvRepository,
  82.                 $semainerdvRepository,
  83.                 $semainesavRepository,
  84.                 $clientRepository,
  85.                 $lieuRepository,
  86.                 $em,
  87.                 $emailenvoiRepository,
  88.                 $paramRepository,
  89.                 $factuRepository);
  90.               }else{
  91.                 switch ($payload['type']) {
  92.                     case 'savrdv':
  93.                         $this->emailrdvsav($parametreRepository,$sendmailservice,$emailenvRepository,$semainerdvRepository,$semainesavRepository,$clientRepository,$lieuRepository,$em);
  94.                         break;
  95.                         case 'emailenv':
  96.                            $p=$paramRepository->valeuret("emailenv");
  97.                            foreach ($p as $k) {
  98.                             # code...
  99.                            }
  100.                             //dd($p);
  101.                           
  102.                             $this->emailenv($k,
  103.                             $parametreRepository,
  104.                             $emailenvoiRepository,
  105.                             $emailenvRepository,
  106.                             $semainerdvRepository,
  107.                             $semainesavRepository,
  108.                             $clientRepository,
  109.                             $lieuRepository,
  110.                             $sendmailservice,
  111.                             $em,
  112.                             $factuRepository);
  113.                             break;
  114.                             case 'contrat':
  115.                                $p=$paramRepository->valeuret("contrat");
  116.                                // dd($p);
  117.                                
  118.                                 $this->factfin($p,
  119.                                 $em,$factuRepository);
  120.                                 break;
  121.                     
  122.                 }}
  123.             }else{$message="error inconu";}
  124.                 break;
  125.         }
  126.         if($email=="ok" && $type!=""){
  127.                  $payload=['type'=> $type];
  128.                 $email="ok";
  129.                 $header=['typ'=> 'JWT',
  130.                     'alg'=>'HS256'];
  131.                 $token$jwt->generate($header,$payload,$this->getParameter('app.jwtsecret'));
  132.                 $message="email envoyer";
  133.                 $url $this->generateUrl('tol_index',['token'=>$token],UrlGeneratorInterface::ABSOLUTE_URL);
  134.                 $serv=new servicedivers();
  135.                 $role=$this->getUser()->getRoles();
  136.                 $val="ko";
  137.                 foreach ($role as $k) {  
  138.                      // dd($k);
  139.                    if($k=="ROLE_ADMIN"){
  140.                     $val="ok";
  141.                    }
  142.                 }
  143.                 if($val=="ok"){
  144.                     $token $this->generateUrl('tol_index',['token'=>$token],UrlGeneratorInterface::ABSOLUTE_URL);
  145.                 //{{ absolute_url(asset('/tol/'))}}{{token}}
  146.                     $serv->emailcron($token,$tache,$url,$parametreRepository,$sendmailservice);
  147.     $message=$token;
  148.             }else{$message="demande non autoriser";}
  149.         }
  150.         return $this->render('tol/index.html.twig', [
  151.             'message' => $message,
  152.         ]);
  153.     }
  154.     private function touactiversendmailservice $sendmailservice,
  155.     ParametreRepository $parametreRepository,
  156.     EmailenvRepository $emailenvRepository,
  157.     SemainerdvRepository $semainerdvRepository,
  158.     SemainesavRepository $semainesavRepository,
  159.     ClientRepository $clientRepository,
  160.     LieuRepository $lieuRepository,
  161.     EntityManagerInterface $em,
  162.     EmailenvoiRepository $emailenvoiRepository,
  163.     ParamRepository $paramRepository,
  164.     FactuRepository $factuRepository){
  165.         $this->emailrdvsav($parametreRepository,$sendmailservice,$emailenvRepository,$semainerdvRepository,$semainesavRepository,$clientRepository,$lieuRepository,$em);
  166.     
  167.         $p=$paramRepository->valeuret("emailenv");
  168.         //dd($p);
  169.       
  170.         $this->emailenv($p,
  171.         $parametreRepository,
  172.         $emailenvoiRepository,
  173.         $emailenvRepository,
  174.         $semainerdvRepository,
  175.         $semainesavRepository,
  176.         $clientRepository,
  177.         $lieuRepository,
  178.         $sendmailservice,
  179.         $em,
  180.         $factuRepository);
  181.                          $p=$paramRepository->valeuret("contrat");
  182.                                // dd($p);
  183.                                
  184.                                 $this->factfin($p,
  185.                                 $em,$factuRepository);
  186.     }
  187.     private function emailrdvsav(ParametreRepository $parametreRepository,
  188.     sendmailservice $email,
  189.     EmailenvRepository $emailenvRepository,
  190.     SemainerdvRepository $semainerdvRepository,
  191.     SemainesavRepository $semainesavRepository,
  192.     ClientRepository $clientRepository,
  193.     LieuRepository $lieuRepository,
  194.     EntityManagerInterface $em){
  195.       // 
  196.       // tout entre 6h et 7h  
  197.       
  198.       $emailenv= new Emailenv();
  199.       $time=time();
  200.       $heure=date('G',time());
  201.         $serv=new servicedivers();
  202.       if($heure>=&& $heure<9){
  203.         $jour=$parametreRepository->getparaIdvalue('emailcronsavrdv');
  204.         $jour++;$jour--;
  205.             $jour=(((3600*24)*$jour))+$serv->debutsemaine($time);
  206.         if($jour<=time()){
  207.       $emailen=$emailenvRepository->getout(1);$val="ok";$a=[];
  208.       foreach ($emailen as $k) {
  209.         $a[]=date('d/m/y G:i:s',$serv->debutsemaine($time));
  210.         $a[]=date('d/m/y G:i:s',$k->getDate());
  211.         $a[]=date('d/m/y G:i:s',$serv->finsemaine($time));
  212.         $a[]=$serv->debutsemaine($time);
  213.         $a[]=$k->getDate();
  214.         $a[]=$serv->finsemaine($time);
  215.         if($k->getDate()>=$serv->debutsemaine($time)){
  216.              
  217.             if($k->getDate()<=$serv->finsemaine($time)){
  218.           
  219.                 $val="ko";
  220.             }}
  221.       }
  222.     if($val=="ok"){
  223.         $times=$time+((3600*24)*7);
  224.         $serv->emailsavrdv($times,$email,$parametreRepository,$semainerdvRepository,$semainesavRepository,$clientRepository,$lieuRepository,1);
  225.             $env= new Emailenv();
  226.             $env->setType(1);
  227.             $env->setDate($time);
  228.         $em->persist($env);
  229.         $em->flush();
  230.     }
  231.  //dd("activation du module rdv sav");
  232.     }
  233.      
  234.  
  235.     }
  236. }
  237. private function emailenv(Param $param,
  238. ParametreRepository $parametreRepository,
  239. EmailenvoiRepository $emailenvoiRepository,
  240. EmailenvRepository $emailenvRepository,
  241. SemainerdvRepository $semainerdvRepository,
  242. SemainesavRepository $semainesavRepository,
  243. ClientRepository $clientRepository,
  244. LieuRepository $lieuRepository,
  245. sendmailservice $sendmailservice,
  246. EntityManagerInterface $em,
  247. FactuRepository $factuRepository)
  248. {
  249.     $minute=$parametreRepository->getparaIdvalue("emailenvnbr");
  250.     $minute++;
  251.     $minute--;
  252.     $time=($minute*60);
  253.     $d=[];
  254.     $d[]=$time;
  255.     $d[]=$param->getValeurint();
  256.     $d[]=$param->getValeurint()+$time;
  257.     $d[]=time();
  258. //dd($d);
  259.     if(time()>($param->getValeurint()+$time)){
  260.         //autoriser a envoyer
  261.             # code...
  262.             
  263.         $serv=new servicedivers();
  264.         $in=$parametreRepository->getparaIdvalue("emailtempnbr");
  265.             $email=$emailenvoiRepository->getemailenv($in);
  266.     //dd($email);
  267.             foreach ($email as $ke) {
  268.                 $val=$ke->getValeur();
  269.           
  270.                // dd($val);
  271.             switch ($ke->getClass()) {
  272.                 case 'SavrdvMessage':
  273.                     
  274.                    $a$serv->emailsavrdv($val->getTime(),$sendmailservice,
  275.                         $parametreRepository,
  276.                         $semainerdvRepository,
  277.                         $semainesavRepository,
  278.                         $clientRepository,
  279.                         $lieuRepository,$val->getRappel());
  280.                         $k=$ke->getDelivred();
  281.                         $k++;
  282.                         $ke->setDelivred($k);
  283.                         if($k>=5){
  284.                         $ke->setDelivred(time());
  285.                             $ke->setErreur(1);
  286.                         }
  287.                     break;
  288.                     case "intervention":
  289.                         $a=  $serv->emailintervention($sendmailservice,
  290.                         $parametreRepository,
  291.                         $val->getemailen(),
  292.                         $val->getobjet(),
  293.                         $val->getmessage(),
  294.                         $val->getfile());
  295.                         break;
  296.                         case "contrat":
  297.                             //dd($val);
  298.                           $a=  $serv->emailcontrat(
  299.                             $sendmailservice,
  300.                             $clientRepository,
  301.                             $lieuRepository,
  302.                             $parametreRepository,
  303.                             $factuRepository,
  304.                             $val);
  305.                             break;
  306.                 default:
  307.                     $a=true;
  308.                     break;
  309.             }
  310.             if($a){
  311.                 $emailenvoiRepository->remove($ke,true);
  312.            }else{
  313.           
  314.             
  315.             $em->persist($ke);
  316.             $em->flush();
  317.            }
  318.           }
  319.           $param->setValeurint(time());
  320.           $em->persist($param);
  321.           $em->flush();
  322.     }
  323. }
  324.   public function factfin(Param $param,
  325.   EntityManagerInterface $em,
  326.   FactuRepository $factuRepository,
  327.   )
  328.   {
  329.     if(time()>($param->getValeurint()+((3600*24)*10))){
  330.    // dd("contrat");
  331.     $j=date("d",time());
  332.     $m=date("m",time());
  333.     $a=date("Y",time());
  334.     $time=time();
  335.     $mod=0;
  336.     if($j>=1){
  337.         if($j<=14){
  338.             $mod=1;
  339.             
  340.         $dmktime(000$m1$a);
  341.         $fmktime(23500$m14$a);
  342.         }
  343.     }
  344.     if($j>=15){
  345.         if($j<=30){
  346.             $mod=2;
  347.             $dmktime(000$m14$a);
  348.             $fmktime(23500$m31$a);
  349.         }
  350.     }
  351.     
  352.     //dd($mod);
  353.     if($mod!=0){
  354.         $d2mktime(23500$m1$a);
  355.         $f2mktime(23500$m31$a);
  356.         $f2=$f2+(((3600*24)*30)*2);
  357.         $d2=$d2+((3600*24)*15);
  358.         $fact=$factuRepository->donner();
  359.         $dg=[];
  360.         foreach ($fact as $k) {
  361.             $time=date_timestamp_get($k->getDatefin());
  362.             if($time>=$d){
  363.                 if($time<=$f){
  364.                     $dg[]=$k->getId();
  365.                 }
  366.             }
  367.         }
  368.         $dg2=[];
  369.         foreach ($fact as $k) {
  370.             $time=date_timestamp_get($k->getDatefin());
  371.             if($time>=$d2){
  372.                 if($time<=$f2){
  373.                     $dg2[]=$k->getId();
  374.                 }
  375.             }
  376.         }
  377.         $ser=new fincontrat("les contrat ".date("d/m/y",$d)." - ".date("d/m/y",$f),$dg,$dg2);
  378.         $emailenvoie=new Emailenvoi();
  379.         $emailenvoie->setClass('contrat');
  380.         $emailenvoie->setValeur($ser);
  381.         $emailenvoie->setCreated(time());
  382.         $emailenvoie->setErreur(0);
  383.        // dd($emailenvoie);
  384.         $em->persist($emailenvoie);
  385.         $em->flush();  
  386.        
  387.     $param->setValeurint(time());
  388.     $em->persist($param);
  389.     $em->flush();}
  390.     }
  391.   }
  392. }