src/Controller/AdminController.php line 454

Open in your IDE?
  1. <?php
  2. namespace App\Controller;
  4. use App\Form\Type\BFFestivalandEditionType;
  5. use Symfony\Component\Routing\Annotation\Route;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use App\Entity\BFChallenge;
  10. use App\Entity\BFChallengeEdition;
  11. use App\Entity\BFFestival;
  12. use App\Entity\BFEdition;
  13. use App\Entity\BFTournoi;
  14. use App\Entity\BFSeance;
  15. use App\Entity\BFUser;
  16. use App\Entity\BFResetPassword;
  17. use App\Entity\BFAdminLicences;
  18. use App\Entity\BFRouting;
  19. use App\Entity\BFSubscription;
  20. use App\Entity\BFMailChallenge;
  21. use App\Entity\BFMailFestival;
  22. use App\Entity\BFMailTournoi;
  23. use App\Entity\BFProductEdition;
  24. use App\Form\Type\BFChallengeType;
  25. use App\Form\Type\BFChallengeEditionType;
  26. use App\Form\Type\BFFestivalType;
  27. use App\Form\Type\BFFestivalOwnerType;
  28. use App\Form\Type\BFFestivalAdministratorAddType;
  29. use App\Form\Type\BFFestivalAdministratorRemoveType;
  30. use App\Form\Type\BFEditionType;
  31. use App\Form\Type\BFTournoiType; 
  32. use App\Form\Type\BFTournoiWithTypeType;
  33. use App\Form\Type\BFSeanceType;
  34. use App\Form\Type\BFUserDescriptionType;
  35. use App\Form\Type\BFDescriptionEditionImagesType;
  36. use App\Form\Type\BFDescriptionFestivalType;
  37. use App\Form\Type\BFDescriptionChallengeType;
  38. use App\Form\Type\ModifyPasswordType;
  39. use App\Form\Type\ModifyEmailType;
  40. use App\Form\Type\AskPasswordType;
  41. use App\Form\Type\RoutingType;
  42. use App\Form\Type\BFMailFestivalType;
  43. use App\Form\Type\BFMailTournoiType;
  44. use App\Form\Type\BFChallengeAddFestivalType;
  45. use App\Form\Type\BFProductEditionType;
  46. use App\Form\Type\FestivalFeeType;
  48. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  49. use Symfony\Component\Form\FormError;
  50. use Symfony\Component\Validator\Validator\ValidatorInterface;
  51. use App\Utilities\Mail;
  53. use Stripe\Stripe;
  54. use Stripe\StripeClient;
  55. use Stripe\StripeAccount;
  58. class AdminController extends AbstractController
  59. {
  60.     
  61.     /**
  62.     * @Route("/admin/festival-{id}", name="admin_festival")
  63.     */
  64.     public function ShowAdminFestival(int $id,ValidatorInterface $validator, Request $request)
  65.     {
  66.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  67.         
  68.         $festival = $this->getDoctrine()
  69.              ->getRepository(BFFestival::class)
  70.              ->find($id);
  71.         
  72.         $this->denyAccessUnlessGranted('edit', $festival);
  73.         
  74.         $user=$this->getUser();
  76.         
  77.         //formdescrition
  78.         $formeditfestival = $this->createForm(BFFestivalType::class, $festival,[
  79.             'submit_label' => 'Editer',
  80.         ]);
  81.         
  82.         $formeditfestival->handleRequest($request);
  83.         if ($formeditfestival->isSubmitted() && $formeditfestival->isValid()) {
  84.             // $form->getData() holds the submitted values
  85.             // but, the original `$task` variable has also been updated
  86.             $festival = $formeditfestival->getData();
  87.                         
  88.             $errors = $validator->validate($festival);
  89.             if(count($errors)>0)
  90.             {
  91.                 foreach($errors as $error)
  92.                 {
  93.                     $this->addFlash('danger', $error->toString());
  94.                 }
  95.             }
  96.             else
  97.             {
  98.                 // ... perform some action, such as saving the task to the database
  99.                 // for example, if Task is a Doctrine entity, save it!
  100.                 $entityManager = $this->getDoctrine()->getManager();
  101.                 $entityManager->persist($festival);
  102.                 $entityManager->flush();
  104.                 $this->addFlash('success', 'Les modifications sont enregistrées');
  105.             }
  106.             
  107.             return $this->redirect($request->getUri());
  108.         }
  109.         if($formeditfestival->isSubmitted() && !$formeditfestival->isValid())
  110.         {
  111.             foreach($formeditfestival->getErrors(true) as $error)
  112.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  113.             return $this->redirect($request->getUri());
  114.         }
  115.         
  116.         
  117.         //formowner
  118.         $emailvalue = $festival->getOwner()!=null ? $festival->getOwner()->getEmail() : "";
  119.         $formfestivalowner = $this->createForm(BFFestivalOwnerType::class, null, [
  120.             'email_value' => $emailvalue ,
  121.         ]);
  122.         
  123.         $formfestivalowner->handleRequest($request);
  124.         if ($formfestivalowner->isSubmitted() && $formfestivalowner->isValid()) {
  125.             $this->denyAccessUnlessGranted('delete', $festival);
  126.             // $form->getData() holds the submitted values
  127.             // but, the original `$task` variable has also been updated
  128.             $email = $formfestivalowner->getData()['email'];
  129.             
  130.             if($email==null)
  131.             {
  132.                 $festival->setOwner(null);
  133.                 $entityManager = $this->getDoctrine()->getManager();
  134.                 $entityManager->persist($festival);
  135.                 $entityManager->flush();
  136.                 
  137.                 $this->addFlash('primary', 'Le propriétaire du festival a été modifié');
  138.             }
  139.             else
  140.             {
  141.                 //getuser from email
  142.                 $owneruser =$this->getDoctrine()
  143.                 ->getRepository(BFUser::class)
  144.                 ->findOneBy(['email'=>$email]);
  146.                 if($owneruser!=null)
  147.                 {
  148.                     $festival->setOwner($owneruser);
  150.                     $entityManager = $this->getDoctrine()->getManager();
  151.                     $entityManager->persist($festival);
  152.                     $entityManager->flush();
  153.                     
  154.                     $this->addFlash('primary', 'Le propriétaire du festival a été modifié');
  155.                 }
  156.                 else
  157.                 {
  158.                     $this->addFlash('danger', 'L\'adresse email est inconnue');
  159.                 }
  160.             }
  161.             return $this->redirect($request->getUri());
  162.         }
  163.         if($formfestivalowner->isSubmitted() && !$formfestivalowner->isValid())
  164.         {
  165.             foreach($formfestivalowner->getErrors(true) as $error)
  166.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  167.             return $this->redirect($request->getUri());
  168.         }
  169.         
  170.         //formaddadministrator
  171.         $formfestivaladministratoradd = $this->createForm(BFFestivalAdministratorAddType::class, null, [
  172.         ]);
  173.         
  174.         $formfestivaladministratoradd->handleRequest($request);
  175.         if ($formfestivaladministratoradd->isSubmitted() && $formfestivaladministratoradd->isValid()) {
  176.             $this->denyAccessUnlessGranted('delete', $festival);
  177.             // $form->getData() holds the submitted values
  178.             // but, the original `$task` variable has also been updated
  179.             $email = $formfestivaladministratoradd->getData()['email'];
  180.             
  181.             //getuser from email
  182.             $adminuser =$this->getDoctrine()
  183.             ->getRepository(BFUser::class)
  184.             ->findOneBy(['email'=>$email]);
  185.             
  186.             if($adminuser!=null)
  187.             {
  188.                 $festival->addAdministrator($adminuser);
  189.                 
  190.                 $entityManager = $this->getDoctrine()->getManager();
  191.                 $entityManager->persist($festival);
  192.                 $entityManager->flush();
  193.                 
  194.                 $this->addFlash('primary', 'L\'administrateur a été ajouté');
  195.                 
  196.                 return $this->redirect($request->getUri());
  197.             }
  198.             else
  199.             {
  200.                 $this->addFlash('danger', 'L\'adresse email est inconnue');
  201.             }
  202.         }
  203.         if($formfestivaladministratoradd->isSubmitted() && !$formfestivaladministratoradd->isValid())
  204.         {
  205.             foreach($formfestivaladministratoradd->getErrors(true) as $error)
  206.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  207.             return $this->redirect($request->getUri());
  208.         }
  209.         
  210.         //formremoveadministrator
  211.         $formfestivaladministratorremove = $this->createForm(BFFestivalAdministratorRemoveType::class, null, ['festival'=>$festival]);
  212.         
  213.         $formfestivaladministratorremove->handleRequest($request);
  214.         if ($formfestivaladministratorremove->isSubmitted() && $formfestivaladministratorremove->isValid()) {
  215.             $this->denyAccessUnlessGranted('delete', $festival);
  216.             
  217.             // $form->getData() holds the submitted values
  218.             // but, the original `$task` variable has also been updated
  219.             $administratorid = $formfestivaladministratorremove->getData()['administratorstodelete'];
  220.             
  221.             $adminuser=null;
  222.             if($administratorid!=null)
  223.             {
  224.                 $adminuser =$this->getDoctrine()->getRepository(BFUser::class)->find($administratorid);
  225.             }
  226.             
  227.             if($adminuser!=null)
  228.             {
  229.                 $festival->removeAdministrator($adminuser);
  230.                 $entityManager = $this->getDoctrine()->getManager();
  231.                 $entityManager->persist($festival);
  232.                 $entityManager->flush();
  233.                 
  234.                 $this->addFlash('primary', 'L\'administrateur a été envelé');
  235.                 
  236.                 return $this->redirect($request->getUri());
  237.             }
  238.         }
  239.         if($formfestivaladministratorremove->isSubmitted() && !$formfestivaladministratorremove->isValid())
  240.         {
  241.             foreach($formfestivaladministratorremove->getErrors(true) as $error)
  242.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  243.             return $this->redirect($request->getUri());
  244.         }
  245.         
  246.         //formrouting
  247.         $bfrouting = $festival->getRoute();
  248.         if($bfrouting==null)
  249.             $bfrouting= new BFRouting();
  250.         
  251.         $formrouting = $this->createForm(RoutingType::class, $bfrouting);
  252.         $formrouting->handleRequest($request);
  253.         if ($formrouting->isSubmitted() && $formrouting->isValid()) {
  254.             $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  255.             $this->denyAccessUnlessGranted('option_uniqueurl_festival', $festival);
  256.             
  257.             $bfrouting = $formrouting->getData();
  258.             
  259.             $entityManager = $this->getDoctrine()->getManager();
  260.             if($festival->getRoute()==null)
  261.             {
  262.                 $festival->setRoute($bfrouting);
  263.                 $entityManager->persist($bfrouting);
  264.                 $entityManager->persist($festival);
  265.             }
  266.             else
  267.             {
  268.                 $entityManager->persist($bfrouting);
  269.             }
  270.             
  271.             $entityManager->flush();
  272.             
  273.             $this->addFlash('primary', 'La route a été enregistrée');
  274.             
  275.             return $this->redirect($request->getUri());
  276.         }
  277.         if($formrouting->isSubmitted() && !$formrouting->isValid())
  278.         {
  279.             foreach($formrouting->getErrors(true) as $error)
  280.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  281.             return $this->redirect($request->getUri());
  282.         }
  283.         
  284.         //form orderfeebf
  285.          $formfeefestival = $this->createForm(FestivalFeeType::class, $festival,[
  286.             
  287.         ]);
  288.         
  289.         $formfeefestival->handleRequest($request);
  290.         if ($formfeefestival->isSubmitted() && $formfeefestival->isValid()) {
  291.             // $form->getData() holds the submitted values
  292.             // but, the original `$task` variable has also been updated
  293.             $festival = $formfeefestival->getData();
  294.                         
  295.             $errors = $validator->validate($festival);
  296.             if(count($errors)>0)
  297.             {
  298.                 foreach($errors as $error)
  299.                 {
  300.                     $this->addFlash('danger', $error->toString());
  301.                 }
  302.             }
  303.             else
  304.             {
  305.                 // ... perform some action, such as saving the task to the database
  306.                 // for example, if Task is a Doctrine entity, save it!
  307.                 $entityManager = $this->getDoctrine()->getManager();
  308.                 $entityManager->persist($festival);
  309.                 $entityManager->flush();
  311.                 $this->addFlash('success', 'La commission a été changée');
  312.             }
  313.             
  314.             return $this->redirect($request->getUri());
  315.         }
  316.         if($formeditfestival->isSubmitted() && !$formeditfestival->isValid())
  317.         {
  318.             foreach($formeditfestival->getErrors(true) as $error)
  319.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  320.             return $this->redirect($request->getUri());
  321.         }
  322.         
  323.         
  324.         //offers and option list
  325.         $bfadminlicences = $this->getDoctrine()->getRepository(BFAdminLicences::class)->findAllByFestival($festival);
  326.         
  327.                 
  328.         return $this->render('adminfestival.html.twig', [
  329.             'userdescription' => $user->getDescription(),
  330.             'formbffestivaledit' => $formeditfestival->createView(),
  331.             'formbffestivalowner' => $formfestivalowner->createView(),
  332.             'formbffestivaladminadd' => $formfestivaladministratoradd->createView(),
  333.             'formbffestivaladminremove' => $formfestivaladministratorremove->createView(),
  334.             'formbffestivalorderfee' => $formfeefestival->createView(),
  335.             'formrouting' =>$formrouting->createView(),
  336.             'bffestival' => $festival,
  337.             'bfadminlicences' => $bfadminlicences,
  338.             'activefestivalid' => $id,
  339.             'stripeaccountvalid' => $this->isGranted('canpay', $festival),
  340.         ]);
  341.     }
  342.     
  343.     /**
  344.     * @Route("/admin/festival-{id}/subscriptions", name="admin_festival_subscriptions")
  345.     */
  346.     public function ShowAdminFestivalSubscriptions(int $id, Request $request)
  347.     {
  348.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  349.         
  350.         $festival = $this->getDoctrine()
  351.              ->getRepository(BFFestival::class)
  352.              ->find($id);
  353.         
  354.         $this->denyAccessUnlessGranted('edit', $festival);
  355.         
  356.         $user=$this->getUser();
  357.         
  358.         //countsubscribers
  359.         $subscriptions = $this->getDoctrine()->getRepository(BFSubscription::class)->FindBy(['festival'=>$festival]);
  360.         
  361.         //formsendmail
  362.         $bfmailfestival = new BFMailFestival();
  363.         
  364.         $formsendmail = $this->createForm(BFMailFestivalType::class, $bfmailfestival);
  365.         $formsendmail->handleRequest($request);
  366.         if ($formsendmail->isSubmitted() && $formsendmail->isValid()) {
  367.             // $form->getData() holds the submitted values
  368.             // but, the original `$task` variable has also been updated
  369.             $bfmailfestival = $formsendmail->getData();
  370.                         
  371.             $bfmailfestival->setFestival($festival);
  372.             $bfmailfestival->setSubscribercount(count($subscriptions));
  373.             $bfmailfestival->setSenddate(new \DateTime('now'));
  374.             
  375.             $em =$this->getDoctrine()->getManager();
  376.             $em->persist($bfmailfestival);
  377.             $em->flush();
  378.             
  379.             $txtmessage = $bfmailfestival->getText();
  380.             $subject = $bfmailfestival->getSubject();
  381.             
  382.             $sendedmail=0;
  383.             
  384.             if($bfmailfestival->getIsadmin())
  385.             {
  386.                 $admins = $festival->getAdministrators()->getValues();
  387.                 $owner = $festival->getOwner();
  389.                 if($owner!=null)
  390.                 {
  391.                     array_push($admins, $owner);
  392.                 }
  393.                 if(count($admins)==0)
  394.                 {
  395.                     $userrepository =$this->getDoctrine()->getRepository(BFUser::class);
  396.                     array_push($admins, $userrepository->findByRole('ROLE_SUPER_ADMIN'));
  397.                 }
  398.                 
  399.                 $htmlmessage = $this->renderView('mail/festivalmail.html.twig', [
  400.                         'subject' => $subject,
  401.                         'message' => $txtmessage,
  402.                         'festival' => $festival,
  403.                         'mailfestival' => $bfmailfestival,
  404.                         'subscriptionid' => 0,
  405.                         'attachmentname' => $bfmailfestival->getAttachmentfiletitle()? $bfmailfestival->getAttachmentfiletitle() : $bfmailfestival->getAttachmentfile(),
  406.                     ]);
  408.                 if(Mail::SendMailToBFUsers($admins, $owner->getEmail(), $subject, $htmlmessage, $txtmessage))
  409.                     $this->addFlash('primary', 'Le mail de test a été envoyé à '.count($admins).' administrateurs');
  410.                 else
  411.                     $this->addFlash('danger', 'Impossible d\'envoyer le mail aux administrateurs ');
  412.             }
  413.             else
  414.             {
  415.                 foreach($subscriptions as $subscription)
  416.                 {
  417.                     $htmlmessage = $this->renderView('mail/festivalmail.html.twig', [
  418.                         'subject' => $subject,
  419.                         'message' => $txtmessage,
  420.                         'festival' => $festival,
  421.                         'mailfestival' => $bfmailfestival,
  422.                         'subscriptionid' => $subscription->getId(),
  423.                         'attachmentname' => $bfmailfestival->getAttachmentfiletitle()? $bfmailfestival->getAttachmentfiletitle() : $bfmailfestival->getAttachmentfile(),
  424.                     ]);
  426.                     if(Mail::SendMailToBFUser($subscription->getUser(), $festival->getOwner()->getEmail(), $subject, $htmlmessage, $txtmessage))
  427.                         $sendedmail++;
  428.                 }
  430.                 $this->addFlash('primary', 'Le mail a été envoyé à '.$sendedmail.' destinataires');
  431.             }
  432.             
  433.             return $this->redirect($request->getUri());
  434.         }
  435.      
  436.         //get sendmail list
  437.         $sendmails = $this->getDoctrine()->getRepository(BFMailFestival::class)->findBy(['festival'=>$festival], ['senddate'=>'DESC']);
  438.         
  439.         return $this->render('adminfestivalsubscriptions.html.twig', [
  440.             'userdescription' => $user->getDescription(),
  441.             'bffestival' => $festival,
  442.             'activefestivalid' => $id,
  443.             'countsubscription' => count($subscriptions),
  444.             'formsendmail' => $formsendmail->createView(),
  445.             'sendmails' => $sendmails,
  446.         ]);
  447.     }
  448.     
  449.     /**
  450.     * @Route("/admin/festival/create", name="admin_festival_create")
  451.     */
  452.     public function CreateAdminFestival(Request $request)
  453.     {
  454.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  455.         $user = $this->getUser() ;
  456.         
  457.         $create = new BFFestival();
  458.         $createedition = new BFEdition();
  459.         $createedition->setFestival($create);
  460.         
  461.         $formbffestivalcreate = $this->createForm(BFFestivalandEditionType::class, $createedition, [
  462.         ]);
  463.         
  464.         $formbffestivalcreate->handleRequest($request);
  465.         if ($formbffestivalcreate->isSubmitted() && $formbffestivalcreate->isValid()) {
  466.             // $form->getData() holds the submitted values
  467.             // but, the original `$task` variable has also been updated
  468.             $edition = $formbffestivalcreate->getData();
  469.             $festival=$edition->getFestival();
  471.             if(!in_array("ROLE_SUPER_ADMIN",$user->getRoles()))
  472.                 $festival->setOwner($user);
  474.             // ... perform some action, such as saving the task to the database
  475.             // for example, if Task is a Doctrine entity, save it!
  476.             $entityManager = $this->getDoctrine()->getManager();
  477.             $entityManager->persist($edition);
  478.             $entityManager->flush();
  479.             
  480.             $this->addFlash('primary', 'Le festival et l\'édition ont été créés');
  482.             if($edition->getIsactive())
  483.             {
  484.                 $this->addFlash('success', 'L\'édition est publiée');
  485.             }
  487.             return $this->redirectToRoute('admin_festival',[
  488.                 'id'=>$festival->getId(),
  489.             ]);
  490.         }
  491.         if($formbffestivalcreate->isSubmitted() && !$formbffestivalcreate->isValid())
  492.         {
  493.             foreach($formbffestivalcreate->getErrors(true) as $error)
  494.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  495.             $formbffestivalcreate->clearErrors(true);
  496.         }
  497.         
  498.         return $this->render('adminfestivalcreate.html.twig', [
  499.             'userdescription' => $user->getDescription(),
  500.             'formbffestivalcreate' => $formbffestivalcreate->createView(),
  501.             'uuid' => uniqid(),
  502.         ]);
  503.     }
  504.     
  505.     /**
  506.     * @Route("/admin/festival-{id}/edition-{idedition}", name="admin_edition")
  507.     */
  508.     public function ShowAdminEdition(int $id, int $idedition, Request $request)
  509.     {
  510.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  511.         
  512.         $edition = $this->getDoctrine()
  513.             ->getRepository(BFEdition::class)
  514.             ->find($idedition);
  515.         
  516.         $festival = $edition->getFestival();
  517.         
  518.         $this->denyAccessUnlessGranted('edit', $festival);
  519.         
  520.         $user= $this->getUser();
  521.         
  522.         //edit about form
  523.         $formbfeditionedit = $this->createForm(BFEditionType::class, $edition,[
  524.             'submit_label' => 'Editer',
  525.         ]);
  526.         
  527.         $formbfeditionedit->handleRequest($request);
  528.         if ($formbfeditionedit->isSubmitted() && $formbfeditionedit->isValid()) {
  529.             $this->denyAccessUnlessGranted('edit', $festival);
  530.             // $form->getData() holds the submitted values
  531.             // but, the original `$task` variable has also been updated
  532.             $edition = $formbfeditionedit->getData();
  533.             
  534.             $edition->CleanLocation();
  535.             
  536.             // ... perform some action, such as saving the task to the database
  537.             // for example, if Task is a Doctrine entity, save it!
  538.             $entityManager = $this->getDoctrine()->getManager();
  539.             $entityManager->persist($edition);
  540.             $entityManager->flush();
  541.             
  542.             $this->addFlash('success', 'Les modifications sont enregistrées');
  543.             
  544.             return $this->redirect($request->getUri());
  545.         }
  546.         if($formbfeditionedit->isSubmitted() && !$formbfeditionedit->isValid())
  547.         {
  548.             foreach($formbfeditionedit->getErrors(true) as $error)
  549.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  550.             return $this->redirect($request->getUri());
  551.         }
  552.         
  553.         //edit images form
  554.         $formbfeditionimagesedit = $this->createForm(BFDescriptionEditionImagesType::class, $edition->getDescription(),[
  555.         ]);
  556.         
  557.         $formbfeditionimagesedit->handleRequest($request);
  558.         if ($formbfeditionimagesedit->isSubmitted() && $formbfeditionimagesedit->isValid()) {
  559.             $this->denyAccessUnlessGranted('edit', $festival);
  560.             // $form->getData() holds the submitted values
  561.             // but, the original `$task` variable has also been updated
  562.             $description = $formbfeditionimagesedit->getData();
  563.             
  564.             $edition= $description->getBfedition();
  566.             // ... perform some action, such as saving the task to the database
  567.             // for example, if Task is a Doctrine entity, save it!
  568.             $entityManager = $this->getDoctrine()->getManager();
  569.             $entityManager->persist($edition);
  570.             $entityManager->flush();
  571.             
  572.             $this->addFlash('success', 'Les modifications sont enregistrées');
  573.             
  574.             return $this->redirect($request->getUri());
  575.         }
  576.         if($formbfeditionimagesedit->isSubmitted() && !$formbfeditionimagesedit->isValid())
  577.         {
  578.             foreach($formbfeditionimagesedit->getErrors(true) as $error)
  579.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  580.             return $this->redirect($request->getUri());
  581.         }
  582.         
  583.         //formrouting
  584.         $bfrouting = $edition->getRoute();
  585.         if($bfrouting==null)
  586.             $bfrouting= new BFRouting();
  587.         
  588.         $formrouting = $this->createForm(RoutingType::class, $bfrouting);
  589.         $formrouting->handleRequest($request);
  590.         if ($formrouting->isSubmitted() && $formrouting->isValid()) {
  591.             $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  592.             $this->denyAccessUnlessGranted('option_uniqueurl_edition', $edition);
  593.             
  594.             $bfrouting = $formrouting->getData();
  595.             
  596.             $entityManager = $this->getDoctrine()->getManager();
  597.             if($edition->getRoute()==null)
  598.             {
  599.                 $edition->setRoute($bfrouting);
  600.                 $entityManager->persist($bfrouting);
  601.                 $entityManager->persist($edition);
  602.             }
  603.             else
  604.             {
  605.                 $entityManager->persist($bfrouting);
  606.             }
  607.             
  608.             $entityManager->flush();
  609.             
  610.             $this->addFlash('primary', 'La route a été enregistrée');
  611.             
  612.             return $this->redirect($request->getUri());
  613.         }
  614.         if($formrouting->isSubmitted() && !$formrouting->isValid())
  615.         {
  616.             foreach($formrouting->getErrors(true) as $error)
  617.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  618.             return $this->redirect($request->getUri());
  619.         }
  620.         
  621.         
  622.         return $this->render('adminedition.html.twig', [
  623.             'userdescription' => $user->getDescription(),
  624.             'formbfeditionedit' => $formbfeditionedit->createView(),
  625.             'formbfeditionimagesedit' => $formbfeditionimagesedit->createView(),
  626.             'formrouting' => $formrouting->createView(),
  627.             'activefestivalid' => $id,
  628.             'editionid' => $idedition,
  629.             'bfedition' => $edition,
  630.             'uuid' => uniqid(),
  631.         ]);
  632.     }
  633.     
  634.     /**
  635.     * @Route("/admin/festival-{id}/edition/create", name="admin_edition_create")
  636.     */
  637.     public function CreateAdminEdition(int $id, Request $request)
  638.     {
  639.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  640.         
  641.         //get festival
  642.         $festival = $this->getDoctrine()->getRepository(BFFestival::class)->find($id);
  643.         
  644.         $this->denyAccessUnlessGranted('edit', $festival);
  645.         
  646.         $user=$this->getUser();
  647.         
  648.         $create = new BFEdition();
  649.         $create->setFestival($festival);
  650.         
  651.         $formbfeditioncreate = $this->createForm(BFEditionType::class, $create,[
  652.             ]);
  653.         
  654.         $formbfeditioncreate->handleRequest($request);
  655.         if ($formbfeditioncreate->isSubmitted() && $formbfeditioncreate->isValid()) {
  656.             // $form->getData() holds the submitted values
  657.             // but, the original `$task` variable has also been updated
  658.             $edition = $formbfeditioncreate->getData();
  659.             $edition->setIsactive(false);
  660.             
  661.             $edition->CleanLocation();
  663.             // ... perform some action, such as saving the task to the database
  664.             // for example, if Task is a Doctrine entity, save it!
  665.             $entityManager = $this->getDoctrine()->getManager();
  666.             $entityManager->persist($edition);
  667.             $entityManager->flush();
  668.             
  669.             $this->addFlash('primary', 'L\'édition est créée');
  671.             return $this->redirectToRoute('admin_edition',[
  672.                 'id' => $edition->getFestival()->getId(),
  673.                 'idedition'=>$edition->getId(),
  674.             ]);
  675.         }
  676.         if($formbfeditioncreate->isSubmitted() && !$formbfeditioncreate->isValid())
  677.         {
  678.             foreach($formbfeditioncreate->getErrors(true) as $error)
  679.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  680.             $formbfeditioncreate->clearErrors(true);
  681.         }
  682.         
  683.         return $this->render('admineditioncreate.html.twig', [
  684.             'userdescription' => $user->getDescription(),
  685.             'formbfeditioncreate' => $formbfeditioncreate->createView(),
  686.             'activefestivalid' => $id,
  687.             'bffestival' => $festival,
  688.             'uuid' => uniqid(),
  689.         ]);
  690.     }
  691.     
  692.     /**
  693.     * @Route("/admin/festival-{id}/edition-{idedition}/tournois", name="admin_edition_tournois")
  694.     */
  695.     public function ShowAdminEditionTournois(int $id, int $idedition)
  696.     {
  697.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  698.         
  699.         $user=$this->getUser();
  700.         
  701.         $edition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  702.         
  703.         return $this->render('admineditiontournois.html.twig', [
  704.             'userdescription' => $user->getDescription(),
  705.             'activefestivalid' => $id,
  706.             'editionid' => $idedition,
  707.             'tournoiid' => 0,
  708.             'bfedition' => $edition,
  709.         ]);
  710.     }
  711.     
  712.     /**
  713.     * @Route("/admin/festival-{id}/edition-{idedition}/tournoi-{idtournoi}", name="admin_edition_tournoiid")
  714.     */
  715.     public function ShowAdminEditionTournoisById(int $id, int $idedition, int $idtournoi)
  716.     {
  717.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  718.         
  719.         $user=$this->getUser();
  720.         
  721.         $edition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  722.         
  723.         return $this->render('admineditiontournois.html.twig', [
  724.             'userdescription' => $user->getDescription(),
  725.             'activefestivalid' => $id,
  726.             'editionid' => $idedition,
  727.             'tournoiid' => $idtournoi,
  728.             'bfedition' => $edition,
  729.         ]);
  730.     }
  731.     
  732.     /**
  733.     * @Route("/admin/festival-{id}/edition-{idedition}/inscriptions", name="admin_edition_inscriptions")
  734.     */
  735.     public function ShowAdminEditionInscriptions(int $id, int $idedition)
  736.     {
  737.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  738.         
  739.         $user=$this->getUser();
  740.         
  741.         $edition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  742.         
  743.         return $this->render('admineditioninscriptions.html.twig', [
  744.             'userdescription' => $user->getDescription(),
  745.             'activefestivalid' => $id,
  746.             'editionid' => $idedition,
  747.             'editionidins' => 0,
  748.             'bfedition' => $edition,
  749.         ]); 
  750.     }
  751.     
  752.     /**
  753.     * @Route("/admin/festival-{id}/edition-{idedition}/inscriptions/contact", name="admin_edition_inscriptions_contact")
  754.     */
  755.     public function ShowAdminEditionInscriptionsContact(int $id, int $idedition, Request $request)
  756.     {
  757.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  758.         
  759.         $bfedition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  760.         $festival = $bfedition->getFestival();
  761.         $user=$this->getUser();
  762.         
  763.         if($bfedition==null) return null;
  764.         
  765.         $bfmailtournoi = new BFMailTournoi();
  766.         
  767.         //form contact
  768.         $formsendmail = $this->createForm(BFMailTournoiType::class, $bfmailtournoi,[
  769.             'edition' => $bfedition,
  770.         ]);
  771.         $formsendmail->handleRequest($request);
  772.         if ($formsendmail->isSubmitted() && $formsendmail->isValid()) {
  773.             $bfmailtournoi = $formsendmail->getData();
  774.             
  775.             $bfinscriptions = $bfmailtournoi->getTournoi()->getInscriptions();
  776.             
  777.             $emails = array();
  778.             if($bfmailtournoi->getIsadmin())
  779.             {
  780.                 $admins = $festival->getAdministrators()->getValues();
  781.                 $owner = $festival->getOwner();
  783.                 if($owner!=null)
  784.                 {
  785.                     array_push($admins, $owner);
  786.                 }
  787.                 
  788.                 foreach($admins as $admin)
  789.                 {
  790.                     array_push($emails, $admin->getEmail());
  791.                 }
  792.                 
  793.             }
  794.             else
  795.             {
  796.                 foreach($bfinscriptions as $bfinscription)
  797.                 {
  798.                     $inscriptionusers = $bfinscription->getAllInscriptionUser();
  800.                     foreach($inscriptionusers as $inscriptionuser)
  801.                     {
  802.                         if($inscriptionuser->getEmail()!=null)
  803.                             array_push($emails, $inscriptionuser->getEmail());
  804.                     }
  805.                 }
  806.             }
  807.             
  808.             $bfmailtournoi->setSenddate(new \DateTime('now'));
  809.             
  810.             $bfmailtournoi->setReceivercount(count($emails));
  811.             
  812.             $em =$this->getDoctrine()->getManager();
  813.             $em->persist($bfmailtournoi);
  814.             $em->flush();
  815.             
  816.             $txtmessage = $bfmailtournoi->getText();
  817.             $subject = $bfmailtournoi->getSubject();
  818.             
  819.             $sendedmail=0;
  821.             foreach($emails as $email)
  822.             {
  823.                 $isuser = $this->getDoctrine()->getRepository(BFUser::class)->findOneBy(['email'=>$email])!=null;
  824.                 $htmlmessage = $this->renderView('mail/tournoimail.html.twig', [
  825.                     'subject' => $subject,
  826.                     'message' => $txtmessage,
  827.                     'festival' => $festival,
  828.                     'mailfestival' => $bfmailtournoi,
  829.                     'isuser' => $isuser,
  830.                     'email' => $email,
  831.                     'attachmentname' => $bfmailtournoi->getAttachmentfiletitle()? $bfmailtournoi->getAttachmentfiletitle() : $bfmailtournoi->getAttachmentfile(),
  832.                 ]);
  833.                 
  834.                 if($festival->getOwner()!=null)
  835.                 {
  836.                     if(Mail::SendMailToMailWithFrom($email, $festival->getOwner()->getEmail(), $subject, $htmlmessage, $txtmessage))
  837.                         $sendedmail++;
  838.                 }
  839.                 else
  840.                 {
  841.                     if(Mail::SendMailToMail($email, $subject, $htmlmessage, $txtmessage))
  842.                         $sendedmail++;
  843.                 }
  844.             }
  846.             $this->addFlash('primary', 'Le mail a été envoyé à '.$sendedmail.' destinataires');
  847.             
  848.             if($sendedmail!=count($emails))
  849.             {
  850.                 $bfmailtournoi->setReceivercount($sendedmail);
  851.                 $em->persist($bfmailtournoi);
  852.                 $em->flush();
  853.             }
  854.             
  855.             return $this->redirect($request->getUri());
  856.         }
  857.         
  858.         $sendmails=$this->getDoctrine()->getRepository(BFMailTournoi::class)->findByEdition($bfedition);
  859.         
  860.         return $this->render('admineditioninscriptionscontact.html.twig', [
  861.             'userdescription' => $user->getDescription(),
  862.             'activefestivalid' => $id,
  863.             'editionid' => $idedition,
  864.             'editionidins' => 1,
  865.             'bfedition' => $bfedition,
  866.             'formsendmail' => $formsendmail->createView(),
  867.             'sendmails' => $sendmails,
  868.         ]);
  869.     }
  870.     
  871.     /**
  872.     * @Route("/admin/festival-{id}/edition-{idedition}/tournois/create", name="admin_tournoi_create")
  873.     */
  874.     public function CreateAdminTournoi(int $id, int $idedition, Request $request)
  875.     {
  876.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  877.         
  878.         $create = new BFTournoi();
  879.         $edition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  880.         
  881.         $festival = $edition->getFestival();
  882.         
  883.         $this->denyAccessUnlessGranted('edit', $festival);
  884.         
  885.         $user=$this->getUser();
  886.         
  887.         $create->setEdition($edition);
  888.         
  889.         if($this->isGranted('option_inscription', $edition))
  890.         {
  891.             $formbftournoicreate = $this->createForm(BFTournoiWithTypeType::class, $create, [
  892.             ]);
  893.         }
  894.         else
  895.         {
  896.             $formbftournoicreate = $this->createForm(BFTournoiType::class, $create, [
  897.             ]);
  898.         }
  899.         
  900.         $formbftournoicreate->handleRequest($request);
  901.         if ($formbftournoicreate->isSubmitted() && $formbftournoicreate->isValid()) {
  902.             // $form->getData() holds the submitted values
  903.             // but, the original `$task` variable has also been updated
  904.             $tournoi = $formbftournoicreate->getData();
  906.             // ... perform some action, such as saving the task to the database
  907.             // for example, if Task is a Doctrine entity, save it!
  908.             $entityManager = $this->getDoctrine()->getManager();
  909.             $entityManager->persist($tournoi);
  910.             $entityManager->flush();
  912.             $edition = $tournoi->getEdition();
  913.             $festival = $edition->getFestival();
  914.             
  915.             $this->addFlash('primary', 'Le tournoi est créé');
  917.             return $this->redirectToRoute('admin_edition_tournoiid',[
  918.                 'id'=>$festival->getId(),
  919.                 'idedition'=>$edition->getId(),
  920.                 'idtournoi'=>$tournoi->getId(),
  921.             ]);
  922.         }
  923.         if($formbftournoicreate->isSubmitted() && !$formbftournoicreate->isValid())
  924.         {
  925.             foreach($formbftournoicreate->getErrors(true) as $error)
  926.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  927.             $formbftournoicreate->clearErrors(true);
  928.         }
  929.         
  930.         return $this->render('admineditiontournoiscreate.html.twig', [
  931.             'userdescription' => $user->getDescription(),
  932.             'formbftournoicreate' => $formbftournoicreate->createView(),
  933.             'activefestivalid' => $id,
  934.             'editionid' => $idedition,
  935.             'bfedition' => $edition,
  936.         ]);
  937.     }
  938.     
  939.     /**
  940.     * @Route("/admin/festival-{id}/edition-{idedition}/tournoi-{idtournoi}/seance/create", name="admin_seance_create")
  941.     */
  942.     public function CreateAdminSeance(int $id, int $idedition, int $idtournoi, Request $request)
  943.     {
  944.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  945.         
  946.         $create = new BFSeance();
  947.         $tournoi= $this->getDoctrine()->getRepository(BFTournoi::class)->find($idtournoi);
  948.         
  949.         $festival = $tournoi->getEdition()->getFestival();
  950.         $this->denyAccessUnlessGranted('edit', $festival);
  951.         
  952.         $user=$this->getUser();
  953.         
  954.         $create->setTournoi($tournoi);
  955.         
  956.         $formbfseancecreate = $this->createForm(BFSeanceType::class, $create, [
  957.         ]);
  958.             
  959.         $formbfseancecreate->handleRequest($request);
  960.         if ($formbfseancecreate->isSubmitted() && $formbfseancecreate->isValid()) {
  961.             // $form->getData() holds the submitted values
  962.             // but, the original `$task` variable has also been updated
  963.             $seance = $formbfseancecreate->getData();
  965.             // ... perform some action, such as saving the task to the database
  966.             // for example, if Task is a Doctrine entity, save it!
  967.             $entityManager = $this->getDoctrine()->getManager();
  968.             $entityManager->persist($seance);
  969.             $entityManager->flush();
  970.             
  971.             $tournoi=$seance->getTournoi();
  972.             $edition=$tournoi->getEdition();
  973.             $festival=$edition->getFestival();
  974.             
  975.             $this->addFlash('primary', 'La séance est créée');
  977.            return $this->redirectToRoute('admin_edition_tournoiid',[
  978.                 'id'=>$festival->getId(),
  979.                 'idedition'=>$edition->getId(),
  980.                 'idtournoi'=>$tournoi->getId(),
  981.             ]);
  982.         }
  983.         if($formbfseancecreate->isSubmitted() && !$formbfseancecreate->isValid())
  984.         {
  985.             foreach($formbfseancecreate->getErrors(true) as $error)
  986.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  987.             $formbfseancecreate->clearErrors(true);
  988.         }
  989.         
  990.         
  991.         return $this->render('admineditionseancecreate.html.twig', [
  992.             'userdescription' => $user->getDescription(),
  993.             'formbfseancecreate' => $formbfseancecreate->createView(),
  994.             'activefestivalid' => $id,
  995.             'editionid' => $idedition,
  996.             'tournoiid' => $idtournoi,
  997.             'bftournoi' => $tournoi,
  998.         ]);
  999.     }
  1000.     
  1001.      /**
  1002.     * @Route("/admin/festival-{id}/edition-{idedition}/tournoi-{idtournoi}/seance-{idseance}", name="admin_seance_edit")
  1003.     */
  1004.     public function ShowAdminSeance(int $id, int $idedition, int $idtournoi, int $idseance, Request $request)
  1005.     {
  1006.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1007.         
  1008.         $seance = $this->getDoctrine()
  1009.             ->getRepository(BFSeance::class)
  1010.             ->find($idseance);
  1011.         
  1012.         $festival=$seance->getTournoi()->getEdition()->getFestival();
  1013.         $this->denyAccessUnlessGranted('edit', $festival);
  1014.         
  1015.         $user=$this->getUser();
  1016.         
  1017.         $formbfseanceedit = $this->createForm(BFSeanceType::class, $seance, [
  1018.             'submit_label' => 'Editer',
  1019.         ]);
  1020.         
  1021.         $formbfseanceedit->handleRequest($request);
  1022.         if ($formbfseanceedit->isSubmitted() && $formbfseanceedit->isValid()) {
  1023.             // $form->getData() holds the submitted values
  1024.             // but, the original `$task` variable has also been updated
  1025.             $seance = $formbfseanceedit->getData();
  1027.             // ... perform some action, such as saving the task to the database
  1028.             // for example, if Task is a Doctrine entity, save it!
  1029.             $entityManager = $this->getDoctrine()->getManager();
  1030.             $entityManager->persist($seance);
  1031.             $entityManager->flush();
  1032.             
  1033.             $tournoi= $seance->getTournoi();
  1034.             $edition = $tournoi->getEdition();
  1035.             $festival = $edition->getFestival();
  1036.             
  1037.             $this->addFlash('success', 'Les modifications sont enregistrées');
  1038.            
  1039.             
  1040.             return $this->redirectToRoute('admin_edition_tournoiid',[
  1041.                 'id'=>$id,
  1042.                 'idedition'=>$idedition,
  1043.                 'idtournoi'=>$idtournoi,
  1044.             ]);
  1045.         }
  1046.         if($formbfseanceedit->isSubmitted() && !$formbfseanceedit->isValid())
  1047.         {
  1048.             foreach($formbfseanceedit->getErrors(true) as $error)
  1049.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1050.             return $this->redirect($request->getUri());
  1051.         }
  1052.         
  1053.         return $this->render('admineditionseance.html.twig', [
  1054.             'userdescription' => $user->getDescription(),
  1055.             'formbfseanceedit' => $formbfseanceedit->createView(),
  1056.             'activefestivalid' => $id,
  1057.             'editionid' => $idedition,
  1058.             'tournoiid' => $idtournoi,
  1059.             'bfseance' => $seance,
  1060.         ]);
  1061.     }
  1062.     
  1063.     /**
  1064.     * @Route ("admin/challenge/create", name="admin_challenge_create")
  1065.     */
  1066.     public function CreateAdminChallenge(Request $request)
  1067.     {
  1068.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1069.         $user = $this->getUser() ;
  1070.         
  1071.         $create = new BFChallenge();
  1072.         
  1073.         $formbfchallengecreate = $this->createForm(BFChallengeType::class, $create, [
  1074.         ]);
  1075.         
  1076.         
  1077.         $formbfchallengecreate->handleRequest($request);
  1078.         if ($formbfchallengecreate->isSubmitted() && $formbfchallengecreate->isValid()) {        
  1079.             $create->setOwner($user);
  1080.             
  1081.             $entityManager = $this->getDoctrine()->getManager();
  1082.             $entityManager->persist($create);
  1083.             $entityManager->flush();
  1084.             
  1085.             $this->addFlash('primary', 'Le challenge est créé');
  1086.             
  1087.             return $this->redirectToRoute('admin_challenge',[
  1088.                 'idchallenge'=>$create->getId(),
  1089.             ]);
  1090.         }
  1091.         if($formbfchallengecreate->isSubmitted() && !$formbfchallengecreate->isValid())
  1092.         {
  1093.             foreach($formbfchallengecreate->getErrors(true) as $error)
  1094.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1095.             $formbfchallengecreate->clearErrors(true);
  1096.         }
  1097.         
  1098.         return $this->render('adminchallengecreate.html.twig', [
  1099.             'userdescription' => $user->getDescription(),
  1100.             'formbfchallengecreate' => $formbfchallengecreate->createView(),
  1101.         ]);
  1102.     }
  1103.     
  1104.      /**
  1105.     * @Route("/admin/challenge-{idchallenge}", name="admin_challenge")
  1106.     */
  1107.     public function ShowAdminChallenge(int $idchallenge,ValidatorInterface $validator, Request $request)
  1108.     {
  1109.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1110.         
  1111.         $challenge = $this->getDoctrine()->getRepository(BFChallenge::class)->find($idchallenge);
  1112.         
  1113.         //$this->denyAccessUnlessGranted('edit', $challenge);
  1114.         
  1115.         $user=$this->getUser();
  1116.         $entityManager=$this->getDoctrine()->getManager();
  1117.         
  1118.         //formdescription
  1119.         $formeditchallenge = $this->createForm(BFChallengeType::class, $challenge, [
  1120.             'submit_label' =>'Editer',
  1121.         ]);
  1122.         
  1123.         $formeditchallenge->handleRequest($request);
  1124.         if(($formeditchallenge->isSubmitted() && $formeditchallenge->isValid()))
  1125.         {
  1126.             $entityManager->persist($challenge);
  1127.             $entityManager->flush();
  1128.             
  1129.             $this->addFlash('success', 'Les modifications sont enregistrées');
  1130.         
  1131.             return $this->redirect($request->getUri());
  1132.         }
  1133.         if($formeditchallenge->isSubmitted() && !$formeditchallenge->isValid())
  1134.         {
  1135.             foreach($formeditchallenge->getErrors(true) as $error)
  1136.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1137.             return $this->redirect($request->getUri());
  1138.         }
  1139.         
  1140.         //formfestivals
  1141.         $festivals = $this->getDoctrine()->getRepository(BFFestival::class)->findAll();
  1142.         
  1143.         foreach($challenge->getFestivals() as $festival)
  1144.         {
  1145.             $key = array_search($festival, $festivals);
  1146.             if($key>=0)
  1147.             {
  1148.                 unset($festivals[$key]);
  1149.             }
  1150.         }
  1151.         
  1152.         
  1153.         $formfestivals = $this->createForm(BFChallengeAddFestivalType::class, null,[
  1154.             'festivals' => $festivals,
  1155.         ] );
  1156.         $formfestivals->handleRequest($request);
  1157.         if($formfestivals->isSubmitted() && $formfestivals->isValid())
  1158.         {
  1159.             $selectedfestivalid = $formfestivals->getData()['addfestival'];
  1160.             $selectedfestival=null;
  1161.             if($selectedfestivalid!=null)
  1162.             {
  1163.                 $selectedfestival = $this->getDoctrine()->getRepository(BFFestival::class)->find($selectedfestivalid);
  1164.             }
  1165.             
  1166.             if($selectedfestival!=null)
  1167.             {
  1168.                 $challenge->addFestival($selectedfestival);
  1169.                 $entityManager = $this->getDoctrine()->getManager();
  1170.                 $entityManager->persist($challenge);
  1171.                 $entityManager->flush();
  1172.                 $this->addFlash('primary', 'Le festival a été ajouté au challenge');
  1173.             }
  1174.             else
  1175.             {
  1176.                 $this->addFlash('danger', 'Impossible d\'ajouter le festival au challenge');
  1177.             }
  1178.             return $this->redirect($request->getUri());
  1179.         }
  1180.         
  1181.         
  1182.         //formowner
  1183.         $emailvalue = $challenge->getOwner()!=null ? $challenge->getOwner()->getEmail() : "";
  1184.         $formchallengeowner = $this->createForm(BFFestivalOwnerType::class, null, [
  1185.             'email_value' => $emailvalue,
  1186.         ]);
  1187.         
  1188.         $formchallengeowner->handleRequest($request);
  1189.         if ($formchallengeowner->isSubmitted() && $formchallengeowner->isValid()) 
  1190.         {
  1191.             //$this->denyAccessUnlessGranted('delete', $challenge);
  1192.             // $form->getData() holds the submitted values
  1193.             // but, the original `$task` variable has also been updated
  1194.             $email = $formchallengeowner->getData()['email'];
  1195.             
  1196.             if($email==null)
  1197.             {
  1198.                 $challenge->setOwner(null);
  1199.                 $entityManager = $this->getDoctrine()->getManager();
  1200.                 $entityManager->persist($challenge);
  1201.                 $entityManager->flush();
  1202.                 
  1203.                 $this->addFlash('primary', 'Le propriétaire du challenge a été modifié');
  1204.             }
  1205.             else
  1206.             {
  1207.                 //getuser from email
  1208.                 $owneruser =$this->getDoctrine()
  1209.                 ->getRepository(BFUser::class)
  1210.                 ->findOneBy(['email'=>$email]);
  1212.                 if($owneruser!=null)
  1213.                 {
  1214.                     $challenge->setOwner($owneruser);
  1216.                     $entityManager = $this->getDoctrine()->getManager();
  1217.                     $entityManager->persist($challenge);
  1218.                     $entityManager->flush();
  1219.                     
  1220.                     $this->addFlash('primary', 'Le propriétaire du challenge a été modifié');
  1221.                 }
  1222.                 else
  1223.                 {
  1224.                     $this->addFlash('danger', 'L\'adresse email est inconnue');
  1225.                 }
  1226.             }
  1227.             return $this->redirect($request->getUri());
  1228.         }
  1229.         if($formchallengeowner->isSubmitted() && !$formchallengeowner->isValid())
  1230.         {
  1231.             foreach($formchallengeowner->getErrors(true) as $error)
  1232.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1233.             return $this->redirect($request->getUri());
  1234.         }
  1235.         
  1236.         //formaddadministrator
  1237.         $formchallengeadministratoradd = $this->createForm(BFFestivalAdministratorAddType::class, null, [
  1238.         ]);
  1239.         
  1240.         $formchallengeadministratoradd->handleRequest($request);
  1241.         if ($formchallengeadministratoradd->isSubmitted() && $formchallengeadministratoradd->isValid()) {
  1242.             //$this->denyAccessUnlessGranted('delete', $challenge);
  1243.             // $form->getData() holds the submitted values
  1244.             // but, the original `$task` variable has also been updated
  1245.             $email = $formchallengeadministratoradd->getData()['email'];
  1246.             
  1247.             //getuser from email
  1248.             $adminuser =$this->getDoctrine()
  1249.             ->getRepository(BFUser::class)
  1250.             ->findOneBy(['email'=>$email]);
  1251.             
  1252.             if($adminuser!=null)
  1253.             {
  1254.                 $challenge->addAdministrator($adminuser);
  1255.                 
  1256.                 $entityManager = $this->getDoctrine()->getManager();
  1257.                 $entityManager->persist($challenge);
  1258.                 $entityManager->flush();
  1259.                 
  1260.                 $this->addFlash('primary', 'L\'administrateur a été ajouté');
  1261.                 
  1262.                 return $this->redirect($request->getUri());
  1263.             }
  1264.             else
  1265.             {
  1266.                 $this->addFlash('danger', 'L\'adresse email est inconnue');
  1267.             }
  1268.         }
  1269.         if($formchallengeadministratoradd->isSubmitted() && !$formchallengeadministratoradd->isValid())
  1270.         {
  1271.             foreach($formchallengeadministratoradd->getErrors(true) as $error)
  1272.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1273.             return $this->redirect($request->getUri());
  1274.         }
  1275.         
  1276.         //formremoveadministrator
  1277.         $formchallengeadministratorremove = $this->createForm(BFFestivalAdministratorRemoveType::class, null, ['festival'=>$challenge]);
  1278.         
  1279.         $formchallengeadministratorremove->handleRequest($request);
  1280.         if ($formchallengeadministratorremove->isSubmitted() && $formchallengeadministratorremove->isValid()) {
  1281.             //$this->denyAccessUnlessGranted('delete', $challenge);
  1282.             
  1283.             // $form->getData() holds the submitted values
  1284.             // but, the original `$task` variable has also been updated
  1285.             $administratorid = $formchallengeadministratorremove->getData()['administratorstodelete'];
  1286.             
  1287.             $adminuser=null;
  1288.             if($administratorid!=null)
  1289.             {
  1290.                 $adminuser =$this->getDoctrine()->getRepository(BFUser::class)->find($administratorid);
  1291.             }
  1292.             
  1293.             if($adminuser!=null)
  1294.             {
  1295.                 $challenge->removeAdministrator($adminuser);
  1296.                 $entityManager = $this->getDoctrine()->getManager();
  1297.                 $entityManager->persist($challenge);
  1298.                 $entityManager->flush();
  1299.                 
  1300.                 $this->addFlash('primary', 'L\'administrateur a été envelé');
  1301.                 
  1302.                 return $this->redirect($request->getUri());
  1303.             }
  1304.         }
  1305.         if($formchallengeadministratorremove->isSubmitted() && !$formchallengeadministratorremove->isValid())
  1306.         {
  1307.             foreach($formchallengeadministratorremove->getErrors(true) as $error)
  1308.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1309.             return $this->redirect($request->getUri());
  1310.         }
  1311.         
  1312.         
  1313.         return $this->render('adminchallenge.html.twig', [
  1314.             'userdescription' => $user->getDescription(),
  1315.             'bfchallenge' => $challenge,
  1316.             'formbfchallengeedit' => $formeditchallenge->createView(),
  1317.             'formbfchallengeowner' => $formchallengeowner->createView(),
  1318.             'formbfchallengeadminadd' => $formchallengeadministratoradd->createView(),
  1319.             'formbfchallengeadminremove' => $formchallengeadministratorremove->createView(),
  1320.             'formaddbffestival' => $formfestivals->createView(),
  1321.             'activechallengeid' => $idchallenge,
  1322.         ]);
  1323.     }
  1324.     
  1325.        /**
  1326.     * @Route("/admin/challenge-{idchallenge}/subscriptions", name="admin_challenge_subscriptions")
  1327.     */
  1328.     public function ShowAdminChallengeSubscriptions(int $idchallenge, Request $request)
  1329.     {
  1330.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1331.         
  1332.         $challenge = $this->getDoctrine()
  1333.              ->getRepository(BFChallenge::class)
  1334.              ->find($idchallenge);
  1335.         
  1336.         $this->denyAccessUnlessGranted('edit', $challenge);
  1337.         
  1338.         $user=$this->getUser();
  1339.         
  1340.         //countsubscribers
  1341.         $subscriptions = $this->getDoctrine()->getRepository(BFSubscription::class)->FindBy(['challenge'=>$challenge]);
  1342.         
  1343.         //formsendmail
  1344.         $bfmailchallenge = new BFMailChallenge();
  1345.         
  1346.         $formsendmail = $this->createForm(BFMailFestivalType::class, $bfmailchallenge);
  1347.         $formsendmail->handleRequest($request);
  1348.         if ($formsendmail->isSubmitted() && $formsendmail->isValid()) {
  1349.             // $form->getData() holds the submitted values
  1350.             // but, the original `$task` variable has also been updated
  1351.             $bfmailfestival = $formsendmail->getData();
  1352.                         
  1353.             $bfmailchallenge->setChallenge($challenge);
  1354.             $bfmailchallenge->setSubscribercount(count($subscriptions));
  1355.             $bfmailchallenge->setSenddate(new \DateTime('now'));
  1356.             
  1357.             $em =$this->getDoctrine()->getManager();
  1358.             $em->persist($bfmailchallenge);
  1359.             $em->flush();
  1360.             
  1361.             $txtmessage = $bfmailchallenge->getText();
  1362.             $subject = $bfmailchallenge->getSubject();
  1363.             
  1364.             $sendedmail=0;
  1365.             
  1366.             if($bfmailchallenge->getIsadmin())
  1367.             {
  1368.                 $admins = $challenge->getAdministrators()->getValues();
  1369.                 $owner = $challenge->getOwner();
  1371.                 if($owner!=null)
  1372.                 {
  1373.                     array_push($admins, $owner);
  1374.                 }
  1375.                 if(count($admins)==0)
  1376.                 {
  1377.                     $userrepository =$this->getDoctrine()->getRepository(BFUser::class);
  1378.                     array_push($admins, $userrepository->findByRole('ROLE_SUPER_ADMIN'));
  1379.                 }
  1380.                 
  1381.                 $htmlmessage = $this->renderView('mail/challengemail.html.twig', [
  1382.                         'subject' => $subject,
  1383.                         'message' => $txtmessage,
  1384.                         'challenge' => $challenge,
  1385.                         'mailchallenge' => $bfmailchallenge,
  1386.                         'subscriptionid' => 0,
  1387.                         'attachmentname' => $bfmailchallenge->getAttachmentfiletitle()? $bfmailchallenge->getAttachmentfiletitle() : $bfmailchallenge->getAttachmentfile(),
  1388.                     ]);
  1390.                 if(Mail::SendMailToBFUsers($admins, $owner->getEmail(), $subject, $htmlmessage, $txtmessage))
  1391.                     $this->addFlash('primary', 'Le mail de test a été envoyé à '.count($admins).' administrateurs');
  1392.                 else
  1393.                     $this->addFlash('danger', 'Impossible d\'envoyer le mail aux administrateurs ');
  1394.             }
  1395.             else
  1396.             {
  1397.                 foreach($subscriptions as $subscription)
  1398.                 {
  1399.                     $htmlmessage = $this->renderView('mail/challengemail.html.twig', [
  1400.                         'subject' => $subject,
  1401.                         'message' => $txtmessage,
  1402.                         'challenge' => $challenge,
  1403.                         'mailchallenge' => $bfmailchallenge,
  1404.                         'subscriptionid' => $subscription->getId(),
  1405.                         'attachmentname' => $bfmailchallenge->getAttachmentfiletitle()? $bfmailchallenge->getAttachmentfiletitle() : $bfmailchallenge->getAttachmentfile(),
  1406.                     ]);
  1408.                     if(Mail::SendMailToBFUser($subscription->getUser(), $challenge->getOwner()->getEmail(), $subject, $htmlmessage, $txtmessage))
  1409.                         $sendedmail++;
  1410.                 }
  1412.                 $this->addFlash('primary', 'Le mail a été envoyé à '.$sendedmail.' destinataires');
  1413.             }
  1414.             
  1415.             return $this->redirect($request->getUri());
  1416.         }
  1417.      
  1418.         //get sendmail list
  1419.         $sendmails = $this->getDoctrine()->getRepository(BFMailChallenge::class)->findBy(['challenge'=>$challenge], ['senddate'=>'DESC']);
  1420.         
  1421.         return $this->render('adminchallengesubscriptions.html.twig', [
  1422.             'userdescription' => $user->getDescription(),
  1423.             'bfchallenge' => $challenge,
  1424.             'countsubscription' => count($subscriptions),
  1425.             'formsendmail' => $formsendmail->createView(),
  1426.             'sendmails' => $sendmails,
  1427.             'activechallengeid' => $idchallenge,
  1428.         ]);
  1429.     }
  1430.     
  1431.     /**
  1432.     * @Route("/admin/challenge-{id}/edition/create", name="admin_challenge_edition_create")
  1433.     */
  1434.     public function CreateAdminChallengeEdition(int $id, Request $request)
  1435.     {
  1436.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1437.         
  1438.         //get challenge
  1439.         $challenge = $this->getDoctrine()->getRepository(BFChallenge::class)->find($id);
  1440.         
  1441.         if($challenge==null)
  1442.             throw $this->createNotFoundException('The challenge doesn\'t exist');
  1443.         
  1444.         $this->denyAccessUnlessGranted('edit', $challenge);
  1445.         
  1446.         $user=$this->getUser();
  1447.         
  1448.         //compute possible editions
  1449.         $festivalsfromchallenge = $challenge->getFestivals();
  1450.         $editionsarray= array();
  1451.         foreach($festivalsfromchallenge as $festival)
  1452.         {
  1453.             $editions = $festival->getEditions();
  1454.             foreach($editions as $edition)
  1455.             {
  1456.                 $challengeeditions=$edition->getChallengeeditions();
  1457.                 //check if the edition is already in a challenge edition
  1458.                 if(count($challengeeditions)>0)
  1459.                 {
  1460.                     $isalreadyhere=false;
  1461.                     //check the possibility if the challenge is the current one
  1462.                     foreach($challengeeditions as $challengeedition)
  1463.                     {
  1464.                         //if yes we don't propose this bfedition because already in an edition of the current challenge
  1465.                         if($challengeedition->getChallenge()==$challenge)
  1466.                         {
  1467.                             $isalreadyhere=true;
  1468.                             break;
  1469.                         }
  1470.                     }
  1471.                     if(!$isalreadyhere)
  1472.                         array_push($editionsarray, $edition);
  1473.                 }
  1474.                 else
  1475.                     array_push($editionsarray, $edition);
  1476.             }
  1477.         }
  1478.         
  1479.         $create = new BFChallengeEdition();
  1480.         $create->setChallenge($challenge);
  1481.         
  1482.         $formbfeditioncreate = $this->createForm(BFChallengeEditionType::class, $create,[
  1483.             'editions'=>$editionsarray ]);
  1484.         
  1485.         $formbfeditioncreate->handleRequest($request);
  1486.         if ($formbfeditioncreate->isSubmitted() && $formbfeditioncreate->isValid()) {
  1487.             // $form->getData() holds the submitted values
  1488.             // but, the original `$task` variable has also been updated
  1489.             $edition = $formbfeditioncreate->getData();
  1490.             $edition->setIsactive(false);
  1491.             
  1492.             // ... perform some action, such as saving the task to the database
  1493.             // for example, if Task is a Doctrine entity, save it!
  1494.             $entityManager = $this->getDoctrine()->getManager();
  1495.             $entityManager->persist($edition);
  1496.             $entityManager->flush();
  1497.             
  1498.             $this->addFlash('primary', 'L\'édition est créée');
  1500.             return $this->redirectToRoute('admin_challenge_edition',[
  1501.                 'id' => $edition->getChallenge()->getId(),
  1502.                 'idedition'=>$edition->getId(),
  1503.             ]);
  1504.             
  1505.         }
  1506.         if($formbfeditioncreate->isSubmitted() && !$formbfeditioncreate->isValid())
  1507.         {
  1508.             foreach($formbfeditioncreate->getErrors(true) as $error)
  1509.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1510.             $formbfeditioncreate->clearErrors(true);
  1511.         }
  1512.         
  1513.         return $this->render('challenges/adminchallengeeditioncreate.html.twig', [
  1514.             'userdescription' => $user->getDescription(),
  1515.             'formbfchallengeeditioncreate' => $formbfeditioncreate->createView(),
  1516.             'challengeid' => $challenge->getId(),
  1517.             'activechallengeid' => $challenge->getId(),
  1518.             'bfchallenge' => $challenge,
  1519.         ]);
  1520.     }   
  1521.     
  1522.     /**
  1523.     * @Route("/admin/challenge/edition-{idedition}", name="admin_challenge_edition")
  1524.     */
  1525.     public function ShowAdminChallengeEdition(int $idedition, Request $request)
  1526.     {
  1527.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1528.         
  1529.         $cedition = $this->getDoctrine()
  1530.             ->getRepository(BFChallengeEdition::class)
  1531.             ->find($idedition);
  1532.         
  1533.         $challenge = $cedition->getChallenge();
  1534.         
  1535.         $this->denyAccessUnlessGranted('edit', $challenge);
  1536.         
  1537.         $user= $this->getUser();
  1538.         
  1539.         //compute possible editions
  1540.         $festivalsfromchallenge = $challenge->getFestivals();
  1541.         $editionsarray= array();
  1542.         foreach($festivalsfromchallenge as $festival)
  1543.         {
  1544.             $editions = $festival->getEditions();
  1545.             array_push($editionsarray, $editions->toArray());
  1546.         }
  1547.         
  1548.         //edit about form
  1549.          $formbfchallengeeditionedit = $this->createForm(BFChallengeEditionType::class, $cedition,[
  1550.             'editions'=>$editionsarray, 'submit_label'=>'Editer' ]);
  1551.         
  1552.         $formbfchallengeeditionedit->handleRequest($request);
  1553.         if ($formbfchallengeeditionedit->isSubmitted() && $formbfchallengeeditionedit->isValid()) {
  1554.             // $form->getData() holds the submitted values
  1555.             // but, the original `$task` variable has also been updated
  1556.             //$cedition = $formbfchallengeeditionedit->getData();
  1557.                         
  1558.             // ... perform some action, such as saving the task to the database
  1559.             // for example, if Task is a Doctrine entity, save it!
  1560.             $entityManager = $this->getDoctrine()->getManager();
  1561.             $entityManager->persist($cedition);
  1562.             $entityManager->flush();
  1563.             
  1564.             $this->addFlash('success', 'Les modifications sont enregistrées');
  1565.             
  1566.             return $this->redirect($request->getUri());
  1567.         }
  1568.         if($formbfchallengeeditionedit->isSubmitted() && !$formbfchallengeeditionedit->isValid())
  1569.         {
  1570.             foreach($formbfchallengeeditionedit->getErrors(true) as $error)
  1571.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1572.             return $this->redirect($request->getUri());
  1573.         }
  1574.         
  1575.         return $this->render('challenges/adminchallengeedition.html.twig', [
  1576.             'userdescription' => $user->getDescription(),
  1577.             'formbfchallengeedition' => $formbfchallengeeditionedit->createView(),
  1578.             'activechallengeid' => $challenge->getId(),
  1579.             'editionid' => $idedition,
  1580.             'bfchallengeedition' => $cedition,
  1581.         ]);
  1582.     }
  1583.     
  1584.     /**
  1585.     * @Route("/admin/edition-{id}/unactive", name="admin_bfedition_unactive")
  1586.     */
  1587.     public function UnactiveEdition(int $id, Request $request)
  1588.     {
  1589.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1590.         
  1591.          $response = $this->forward('App\Controller\BFEditionController::ChangeActiveEdition', [
  1592.             'id'  => $id,
  1593.             'isactive' => false,
  1594.             'fromadmin'=> true,
  1595.              'request' =>$request,
  1596.          ]);
  1597.         
  1598.         return $response;
  1599.     }
  1600.     
  1601.     /**
  1602.     * @Route("/admin/edition-{id}/active", name="admin_bfedition_active")
  1603.     */
  1604.     public function ActiveEdition(int $id, Request $request)
  1605.     {
  1606.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1607.         
  1608.         $response = $this->forward('App\Controller\BFEditionController::ChangeActiveEdition', [
  1609.             'id'  => $id,
  1610.             'isactive' => true,
  1611.             'fromadmin'=> true,
  1612.              'request' =>$request,
  1613.          ]);
  1614.         
  1615.         return $response;
  1616.     }
  1617.     
  1618.     /**
  1619.     * @Route("/admin/festival-{id}/edition-{idedition}/cardspreview", name="admin_edition_cardspreview")
  1620.     */
  1621.     public function ShowCardsPreview(int $id, int $idedition, Request $request)
  1622.     {
  1623.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1624.         
  1625.         $bfedition = $this->getDoctrine()->getRepository(BFEdition::class)->find($idedition);
  1626.         $festival=$bfedition->getFestival();
  1627.         
  1628.         $this->denyAccessUnlessGranted('edit', $festival);
  1629.         
  1630.         if($this->isGranted('option_uniqueurl_festival', $festival) && $festival->getRoute()!=null)
  1631.         {
  1632.             $route = $this->generateUrl('home_route',[
  1633.                 'route' => $festival->getRoute()->getRoute(),
  1634.             ]);
  1635.         }
  1636.         else if ($this->isGranted('option_uniqueurl_edition', $bfedition) && $bfedition->getRoute()!=null)
  1637.         {
  1638.             $route = $this->generateUrl('home_route',[
  1639.                 'route' => $bfedition->getRoute()->getRoute(),
  1640.             ]);
  1641.         }
  1642.         else
  1643.         {
  1644.             $route = $this->generateUrl('edition_view',[
  1645.                 'id' => $id,
  1646.             ]);
  1647.         }
  1648.         
  1649.         return $this->render('homepreview.html.twig', [
  1650.             'bfedition' => $bfedition,
  1651.             'bfeditionroute' => $route,
  1652.         ]);
  1653.     }
  1654.     
  1655.     
  1656.     /**
  1657.     * @Route("/admin/festival-{id}/edition-{idedition}/payements", name="admin_edition_payements")
  1658.     */
  1659.     public function ShowAdminEditionPayement($id, $idedition,Request $request)
  1660.     {
  1661.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1662.         
  1663.         $bfedition = $this->getDoctrine()
  1664.             ->getRepository(BFEdition::class)
  1665.             ->find($idedition);
  1666.         
  1667.         $festival = $bfedition->getFestival();
  1668.         
  1669.         $this->denyAccessUnlessGranted('edit', $festival);
  1670.         
  1671.         $user= $this->getUser();
  1672.         
  1673.         $producteditions = $bfedition->getBfproducteditions();
  1674.         
  1675.         $producteditionsbuy=array();
  1676.         $produceditionsquantity=array();
  1677.         $producteditionssum=array();
  1678.         
  1679.         foreach($producteditions as $productedition)
  1680.         {
  1681.             $isbuy=false;
  1682.             $quantity=0;
  1683.             $sum=0;
  1684.             $ordereditions = $productedition->getBFOrderEditions();
  1685.             foreach($ordereditions as $orderedition)
  1686.             {
  1687.                 $paymentintent = $orderedition->getBFPaymentIntentEdition();
  1688.                 if($paymentintent->getSuccessdate()!=null && $paymentintent->getRefunddate()==null)
  1689.                 {
  1690.                     $isbuy=true;
  1691.                     $quantity+=$orderedition->getQuantity();
  1692.                     $sum+=$orderedition->getDisplayTotal();
  1693.                 }
  1694.             }
  1695.             if($isbuy)
  1696.             {
  1697.                 array_push($producteditionsbuy, $productedition);
  1698.                 array_push($produceditionsquantity, $quantity);
  1699.                 array_push($producteditionssum, $sum);
  1700.             }
  1701.         }
  1702.         
  1703.         
  1704.         return $this->render('admineditionpayments.html.twig', [
  1705.             'userdescription' => $user->getDescription(),
  1706.             'bfedition' => $bfedition,
  1707.             'activefestivalid' => $festival->getId(),
  1708.             'editionid' => $bfedition->getId(),
  1709.             'arrayproducteditions' => $producteditionsbuy,
  1710.             'arrayquantity' => $produceditionsquantity,
  1711.             'arraysum' => $producteditionssum,
  1712.         ]);
  1713.     }
  1714.     
  1715.     /**
  1716.     * @Route("/admin/festival-{id}/edition-{idedition}/payements/create", name="admin_edition_payements_create")
  1717.     */
  1718.     public function CreateAdminProductEdition($id, $idedition,Request $request)
  1719.     {
  1720.         $this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
  1721.         
  1722.         $bfedition = $this->getDoctrine()
  1723.             ->getRepository(BFEdition::class)
  1724.             ->find($idedition);
  1725.         
  1726.         $festival = $bfedition->getFestival();
  1727.         
  1728.         $this->denyAccessUnlessGranted('edit', $festival);
  1729.         
  1730.         $user= $this->getUser();
  1731.         
  1732.         $newproduct = new BFProductEdition();
  1733.         
  1734.         //edit about form
  1735.         $formbfproductedition = $this->createForm(BFProductEditionType::class, $newproduct ,[
  1736.             'edition'=> $bfedition, 'submit_label'=>'Créer' ]);
  1737.         
  1738.         $formbfproductedition->handleRequest($request);
  1739.         if ($formbfproductedition->isSubmitted() && $formbfproductedition->isValid()) {
  1740.             
  1741.             $newproduct->setEdition($bfedition);
  1742.             
  1743.             $entityManager = $this->getDoctrine()->getManager();
  1744.             $entityManager->persist($newproduct);
  1745.             $entityManager->flush();
  1746.             
  1747.             $this->addFlash('success', 'Le nouveau forfait est créé');
  1748.             
  1749.             return $this->redirectToRoute('admin_edition_payements', ['id' => $id, 'idedition' => $idedition]);
  1750.         }
  1751.         if($formbfproductedition->isSubmitted() && !$formbfproductedition->isValid())
  1752.         {
  1753.             foreach($formbfproductedition->getErrors(true) as $error)
  1754.                 $this->addFlash('danger', "(".$error->getOrigin()->getName().") ".$error->getMessage());
  1755.             return $this->redirect($request->getUri());
  1756.         }
  1757.         
  1758.         return $this->render('payments/adminproducteditioncreate.html.twig', [
  1759.             'userdescription' => $user->getDescription(),
  1760.             'activefestivalid' => $festival->getId(),
  1761.             'editionid' => $bfedition->getId(),
  1762.             'bfedition' => $bfedition,
  1763.             'formbfproductedition' => $formbfproductedition->createView(),
  1764.         ]);
  1765.     }
  1766.     
  1767.     
  1768.     private function ClearUserResetPassword(BFUser $bfuser)
  1769.     {
  1770.         //get bfreset from user id
  1771.         $bfresetpassword = $this->getDoctrine()->getRepository(BFResetPassword::class)->findOneBy(['user'=>$bfuser]);
  1772.         
  1773.         if($bfresetpassword!=null)
  1774.         {
  1775.             $entityManager = $this->getDoctrine()->getManager();
  1776.             $entityManager->remove($bfresetpassword);
  1777.             $entityManager->flush();
  1778.         }
  1779.         
  1780.     }
  1781. }
  1783. ?>