src/Controller/Utils/adminController.php line 268

Open in your IDE?
  1. <?php
  3. /*
  4.  * To change this license header, choose License Headers in Project Properties.
  5.  * To change this template file, choose Tools | Templates
  6.  * and open the template in the editor.
  7.  */
  9. namespace App\Controller\Utils;
  11. use Symfony\Component\HttpFoundation\Request;
  12. use Symfony\Component\HttpFoundation\Response;
  13. use Symfony\Component\Routing\Annotation\Route;
  14. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  15. //use Symfony\Component\DependencyInjection\ContainerInterface;
  16. //
  17. //use Symfony\Component\HttpFoundation\Session\Session;
  18. use Symfony\Component\Form\Extension\Core\Type\TextType;
  19. //use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  20. //use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
  21. //use Symfony\Component\Form\Extension\Core\Type\IntegerType;
  22. //use Symfony\Component\Form\Extension\Core\Type\DateType;
  23. //use Symfony\Component\Form\Extension\Core\Type\EmailType;
  24. //use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  25. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  26. use Symfony\Component\Form\Extension\Core\Type\FileType;
  27. use Symfony\Component\Validator\Constraints\File;
  28. //use Symfony\Component\Form\Extension\Core\Type\CollectionType;
  29. use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
  30. use Symfony\Component\Form\Extension\Core\Type\PasswordType;
  31. use Symfony\Component\HttpFoundation\RequestStack;
  32. //use Symfony\Component\Form\Extension\Core\Type\TextareaType;
  33. //use Symfony\Component\Finder\Finder;
  34. //use Symfony\Component\Security\Core\User\UserInterface;
  35. //use Symfony\Component\HttpFoundation\File\UploadedFile;
  36. use Doctrine\ORM\EntityManagerInterface;
  37. //use App\Bundle\Model\Utility;
  38. //use Symfony\Component\Security\Core\Encoder\MessageDigestPasswordEncode;
  39. //use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  40. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  41. use Symfony\Component\HttpFoundation\RedirectResponse;
  42. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  43. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  44. //
  45. use App\Service\UtilityServices;
  46. use App\Service\PasswordServices;
  47. use App\Form\Type\UserType;
  48. //use App\Form\Type\RegistrationFormType;
  49. use App\Entity\User;
  50. //
  51. //use Ramsey\Uuid\Uuid;
  52. use Symfony\Component\Uid\Uuid;
  53. use Symfony\Component\Uid\NilUuid;
  55. //
  56. //use SunCat\MobileDetectBundle\mobiledetectlib\MobileDetect as MD;
  57. //use SunCat\MobileDetectBundle\DeviceDetector\MobileDetector;
  58. //use App\Controller\EntityManagerInterface;
  59. //use Symfony\Component\HttpKernel\Exception\HttpException;
  60. //use SunCat\MobileDetectBundle\MobileDetectBundle\MobileDetect;
  62. /**
  63.  * Description of adminController
  64.  *
  65.  * @author efaneuf2
  66.  */
  67. class adminController extends AbstractController {
  69.     private $em;
  70.     private $params;
  71.     private $mobileDetector;
  72.     private $websiterooturl;
  73.     private $requestStack;
  74.     private $baseUrl;
  75.     private $baseURLUC;
  77.     public function __construct(ParameterBagInterface $params, EntityManagerInterface $em, RequestStack $requestStack, string $projectDir) {
  78. //$this->mobileDetector = $mobileDetector;
  79.         $this->params = $params;
  80.         $this->em = $em;
  81. //dd($params);
  82.         $this->requestStack = $requestStack;
  83.         $request = $this->requestStack->getCurrentRequest();
  84.         $this->baseUrl = $request->getSchemeAndHttpHost();
  85.         $this->baseURLUC = strtoupper(str_replace('https://', '', $this->baseUrl));
  87.         $this->websiterooturl = $projectDir;
  88.     }
  90.     /**
  91.      * @Route("/admin/addUserByList", name="adduserbylist")
  92.      */
  93.     public function addUserbylist(Request $request, UserPasswordEncoderInterface $passwordEncoder) {
  94.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  95.             return new RedirectResponse('/login');
  96.         }
  97.         // fetch a list file.
  98.         // Columns (comma seperated)<br>
  99.         //            1 firstname middle name,<br>                  
  100.         //            2 isTeacher (0 or 1),<br>
  101.         //            3 isDeceased (0 or 1),<br>
  102.         //            4 death date,<br>
  103.         //            5 birthday (blank if not known),<br>
  104.         $defaultData = ['message' => 'Type your message here'];
  105.         $Repository = $this->getDoctrine()->getRepository(User::class);
  106.         $form = $this->createFormBuilder($defaultData)
  107.                 ->add('theFilename', FileType::class, [
  108.                     'label' => 'User List (TXT file)',
  109.                     // unmapped means that this field is not associated to any entity property
  110.                     'mapped' => false,
  111.                     // make it optional so you don't have to re-upload the PDF file
  112.                     // every time you edit the Product details
  113.                     'required' => false,
  114.                     // unmapped fields can't define their validation using annotations
  115.                     // in the associated entity, so you can use the PHP constraint classes
  116.                     'constraints' => [
  117.                         new File([
  118.                             'maxSize' => '1024k',
  119.                             'mimeTypes' => [
  120.                                 'text/plain',
  121.                             ],
  122.                             'mimeTypesMessage' => 'Please upload a valid TXT document',
  123.                                 ])
  124.                     ],
  125.                 ])
  126.                 ->add('send', SubmitType::class)
  127.                 ->getForm();
  129.         $form->handleRequest($request);
  131.         if ($form->isSubmitted() && $form->isValid()) {
  132.             // this will be the special name that is moved up to the server.
  133.             // We really do not need the PC name. We are going to immeadiatly
  134.             // process this files rows anyway
  135.             $txtfile = $form->get('theFilename')->getData();
  137.             if ($txtfile) {
  139.                 $path_parts = pathinfo($txtfile->getClientOriginalName());
  140.                 //echo $path_parts['dirname'], "<br>";
  141.                 //echo $path_parts['basename'], "<br>";
  142.                 //echo $path_parts['extension'], "<br>";
  143.                 //echo $path_parts['filename'], "<br>";
  144.                 //echo $txtfile, "<br>";
  146.                 $handle = fopen($txtfile, "r");
  148.                 if ($handle) {
  149.                     while (($line = fgets($handle)) !== false) {
  150.                         $cleanline = trim($line);
  151.                         if ($cleanline != '') {
  152.                             $lineAr = explode(",", $line);
  153.                             // if sizeof the array is not 5 items, issue fail
  154.                             $sz = sizeof($lineAr);
  155.                             if ($sz < 5) {
  156.                                 echo "file has invalid format ($sz columns found)<br>";
  157.                                 die();
  158.                             } else {
  159.                                 //echo "Name: " . $lineAr[0] . "<br>";
  160.                                 // split name into 2 or 3 parts
  161.                                 $nmPartsAR = explode(" ", $lineAr[0]);
  162. //                                if (sizeof($nmPartsAR) == 2) {
  163. //                                    echo "First Name:" . $nmPartsAR[0] . "<br>";
  164. //                                    echo "Last Name:" . $nmPartsAR[1] . "<br>";
  165. //                                } elseif (sizeof($nmPartsAR) == 3) {
  166. //                                    echo "First Name:" . $nmPartsAR[0] . "<br>";
  167. //                                    echo "Middle Name:" . $nmPartsAR[1] . "<br>";
  168. //                                    echo "Last Name:" . $nmPartsAR[2] . "<br>";
  169. //                                } else {
  170. //                                    echo "Failed to split name<br>";
  171. //                                }
  172.                                 //echo "Is A Teacher:" . (($lineAr[1] == 1) ? 'YES' : 'NO') . "<br>";
  173.                                 //echo "Is Deceased:" . (($lineAr[2] == 1) ? 'YES' : 'NO') . "<br>";
  174.                                 //if ($lineAr[2] == 1) {
  175.                                 //    echo "When Died:" . $lineAr[3] . "<br>";
  176.                                 //}
  177.                                 //echo "Birthday:" . $lineAr[4] . "<br><br>";
  178.                                 // check database and see if this user is already there. If not add them
  179.                                 //$User->setRoles(['ROLE_USER']); // set the basic access always
  181.                                 if (sizeof($nmPartsAR) == 2) {
  182.                                     $SearchUser = $Repository->findUserbyName(strtolower($nmPartsAR[0]), strtolower($nmPartsAR[1]));
  183.                                 } elseif (sizeof($nmPartsAR) == 3) {
  184.                                     $SearchUser = $Repository->findUserbyName(strtolower($nmPartsAR[0]), strtolower($nmPartsAR[2]));
  185.                                 }
  186.                                 if ($SearchUser) {
  187.                                     //dd($SearchUser);
  188.                                     echo "This user is already in the database<hr><br>";
  189.                                 } else {
  190.                                     //echo "We need to add this user<hr><br>Adding them now<br>";
  191.                                     if (sizeof($nmPartsAR) == 2) {
  192.                                         $Repository->SetUser($nmPartsAR[0], "", $nmPartsAR[1], $lineAr[1], $lineAr[2], $lineAr[3], $passwordEncoder);
  193.                                     } elseif (sizeof($nmPartsAR) == 3) {
  194.                                         $Repository->SetUser($nmPartsAR[0], $nmPartsAR[1], $nmPartsAR[2], $lineAr[1], $lineAr[2], $lineAr[3], $passwordEncoder);
  195.                                     }
  196.                                 }
  198.                                 //echo $line."<br>";
  199.                             }
  200.                         } //else {
  201. //                            echo "Found blank line<br>";
  202. //                        }
  203.                     }
  205.                     fclose($handle);
  206.                 } else {
  207.                     // error opening the file.
  208.                     echo "ERROR<br>";
  209.                 }
  210.                 //die();
  211.             }
  212.             $Users = $Repository->findAllUsersByName();
  213.             return $this->render('admin/users.html.twig', ['users' => $Users]);
  214.         }
  216.         return $this->render('admin/userFlatFileLoader.html.twig', ['form' => $form->createView()]);
  217.     }
  219.     /**
  220.      * @Route("/forgotpassword", name="forgotpassword")
  221.      */
  222.     public function forgotPassword(
  223. //SessionInterface $session,
  224.             PasswordServices $pwdgen,
  225.             //AuthorizationCheckerInterface $authChecker, 
  226.             UtilityServices $utils,
  227.             UserPasswordEncoderInterface $passwordEncoder,
  228.             Request $request) {
  230.         $User = new User();
  232.         $form = $this->createForm(UserType::class, $User,
  233.                         [
  234.                             'UtilityServices' => $utils,
  235.                             'generateStrongPasswordSvc' => $pwdgen,
  236.                             'editmode' => true,
  237.                             'editlabel' => 'Add User',
  238.                             'em' => $this->get('doctrine')->getManager(),
  239.                             'formstyle' => 'long',
  240.                             'nextuserid' => 0
  241.                         ]
  242.                 )
  243.                 ->add('username', TextType::class, ['label' => 'username or email '])
  244.                 ->add('save', SubmitType::class, ['label' => 'Get New Password'])
  245.         ;
  247. //        $form->get('allowEmail')->setData(true);
  249.         $form->handleRequest($request);
  251.         if ($form->isSubmitted() && $form->isValid()) {
  252. // is the username or password registered with us
  253. // YES
  254. // generate a unique ID to send to user
  255. // save this unique ID into a column in the user account we located
  256. // create email
  257. //NO
  258. // do nothing
  260.             return $this->render('security/forgotPasswordMsgSent.html.twig');
  261.         }
  262.         return $this->render('security/forgotPassword.html.twig', ['form' => $form->createView()]);
  263.     }
  265.     /**
  266.      * @Route("/", name="homepage")
  267.      */
  268.     public function defaultScreen(Request $request): Response {
  269. // $name = $request->query->get('hello')
  270. //$mobileDetector = $this->get('mobile_detect.mobile_detector');
  271. //$mobileDetector = $md;
  272. //$mobileDetector->isMobile();
  273. //$mobileDetector->isTablet();
  274.         return $this->render('default.html.twig');
  275.     }
  277.     /**
  278.      * @Route("/about", name="about")
  279.      */
  280.     public function about(Request $request): Response {
  281.         return $this->render('about.html.twig');
  282.     }
  284.     /**
  285.      * @Route("/maintenance", name="maintenance")
  286.      */
  287.     public function maintenance(Request $request): Response {
  288.         return $this->render('maintenanceMode.html.twig');
  289.     }
  291.     /**
  292.      * @Route("/tos", name="tos")
  293.      */
  294.     public function tos(Request $request): Response {
  296.         return $this->render('TOS.html.twig', [
  297.                     'SCN' => 'SJC',
  298.                     'FCN' => 'SJC Creations',
  299.                     'WSURL' => $this->websiterooturl,
  300.                     'SWSN' => $this->baseURLUC,
  301.                     'CONTACTEMAIL' => 'summerlinearl AT gmail.com',
  302.                     'SITEALIAS' => $this->baseURLUC,
  303.                     'EFFDATE' => 'April 1st, 2020'
  304.         ]);
  305.     }
  307.     /**
  308.      * @Route("/copyright", name="copyright")
  309.      */
  310.     public function copyright(Request $request): Response {
  311.         return $this->render('copyright.html.twig', [
  312.                     'SCN' => 'SJC',
  313.                     'FCN' => 'SJC Creations',
  314.                     'WSURL' => $this->websiterooturl,
  315.                     'SWSN' => $this->baseURLUC,
  316.                     'CONTACTEMAIL' => 'summerlinearl AT gmail.com',
  317.                     'SITEALIAS' => $this->baseURLUC,
  318.                     'EFFDATE' => 'April 1st, 2020'
  319.         ]);
  320.     }
  322.     /**
  323.      * @Route("/privacy", name="privacy")
  324.      */
  325.     public function privacy(Request $request): Response {
  326.         return $this->render('privacy.html.twig', [
  327.                     'SCN' => 'SJC',
  328.                     'FCN' => 'SJC Creations',
  329.                     'WSURL' => $this->websiterooturl,
  330.                     'SWSN' => $this->baseURLUC,
  331.                     'CONTACTEMAIL' => 'summerlinearl AT gmail.com',
  332.                     'SITEALIAS' => $this->baseURLUC,
  333.                     'EFFDATE' => 'April 1st, 2020'
  334.         ]);
  335.     }
  337.     /**
  338.      * @Route("/admin/addUser", name="adduser")
  339.      */
  340.     public function addUser(
  341.             //SessionInterface $session,
  342.             PasswordServices $pwdgen,
  343.             //AuthorizationCheckerInterface $authChecker, 
  344.             UtilityServices $utils,
  345.             UserPasswordEncoderInterface $passwordEncoder,
  346.             Request $request
  347.     ) {
  349.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  350.             return new RedirectResponse('/login');
  351.         }
  352.         $Repository = $this->getDoctrine()->getRepository(User::class);
  354.         $User = new User();
  355.         // these 3 items are set this way by default in the User class
  356.         $User->setRoles(['ROLE_USER']); // set the basic access always
  358.         $nextUserID = $Repository->getNextUserID();
  360.         //$uuid = Uuid::v4();
  361.         //$User->setId($uuid->toBase32());
  362.         //dd($User);
  363.         $form = $this->createForm(UserType::class, $User,
  364.                         [
  365.                             'UtilityServices' => $utils,
  366.                             'generateStrongPasswordSvc' => $pwdgen,
  367.                             'editmode' => true,
  368.                             'editlabel' => 'Add User',
  369.                             'em' => $this->get('doctrine')->getManager(),
  370.                             'formstyle' => 'long',
  371.                             'nextuserid' => $nextUserID
  372.                         ]
  373.                 )
  374.                 ->add('password', RepeatedType::class, [
  375.                     'required' => true,
  376.                     'invalid_message' => 'The password fields must match.',
  377.                     'type' => PasswordType::class,
  378.                     'first_options' => ['label' => 'Password'],
  379.                     'second_options' => [
  380.                         'label' => 'Confirm Password']
  381.                         ]
  382.                 )
  383.                 ->add('save', SubmitType::class, ['label' => 'Save'])
  384.         ;
  386.         $form->handleRequest($request);
  388.         if ($form->isSubmitted() && $form->isValid()) {
  390.             if (!empty(trim($form->get('password')->getData()))) {
  391.                 $new_password = $form->get('password')->getData();
  392.                 $User->setPassword(
  393.                         $passwordEncoder->encodePassword($User, $new_password)
  394.                 );
  395.             }
  398.             //$User = $this->get('security.token_storage')->getToken()->getUser();
  399.             //$UserId = $User->getId();
  401.             $uuid = Uuid::v4();
  402.             $uuid_rfc4122 = $uuid->toRfc4122(); // string(36) "d9e7a184-5d5b-11ea-a62a-3499710062d0"
  403.             $uuid_binary = $uuid->toBinary();  // string(16) "\xd9\xe7\xa1\x84\x5d\x5b\x11\xea\xa6\x2a\x34\x99\x71\x00\x62\xd0"
  404.             $uuid_base32 = $uuid->toBase32();  // string(26) "6SWYGR8QAV27NACAHMK5RG0RPG"
  405.             //$uuid_base58 = $uuid->toBase58();  // string(22) "TuetYWNHhmuSQ3xPoVLv9M"
  406.             //dd($uuidbinday);
  409.             $User->setId($uuid_base32);
  411.             //dd($uuid_base32);
  412.             $User->setCreatedatuserid($uuid_base32);
  413.             $User->setUpdatedatuserid($uuid_base32);
  415.             $currentdate = new \DateTime('now');
  416.             $User->setCreatedate($currentdate);
  417.             $User->setModificationdate($currentdate);
  418.             $User->setRoles2(implode(",", $form->get('roles')->getData()));
  419.             if (!$User->getRoles2()) {
  420.                 $User->setRoles2('ROLE_USER');
  421.             }
  422.             $this->em->persist($User);
  423.             $this->em->flush();
  425.             //$Repository = $this->getDoctrine()->getRepository(user::class);
  426.             //$Users = $Repository->findAll();
  427.             $Users = $Repository->findAllUsersByName();
  428.             return $this->render('admin/users.html.twig', ['users' => $Users]);
  429.         }
  430.         return $this->render('admin/userAdd.html.twig', ['form' => $form->createView(), 'editmode' => false]);
  431.     }
  433.     /**
  434.      * @Route("/edituser/{id}", name="edituser")
  435.      */
  436.     public function editUser(
  437.             //SessionInterface $session,
  438.             PasswordServices $pwdgen,
  439.             //AuthorizationCheckerInterface $authChecker, 
  440.             UtilityServices $utils,
  441.             Request $request,
  442.             UserPasswordEncoderInterface $passwordEncoder,
  443.             $id): Response {
  445.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  446.             return new RedirectResponse('/login');
  447.         }
  448.         //$currentdate = new \DateTime('now');
  449.         $Repository = $this->getDoctrine()->getRepository(User::class);
  451.         // convert the 32 bit binary number in the database to the
  452.         // uuid format we normally like to see
  453.         $uuid = Uuid::fromString($id);
  454.         $uuid_rfc4122 = $uuid->toRfc4122(); // string(36) "d9e7a184-5d5b-11ea-a62a-3499710062d0"
  455.         $uuid_binary = $uuid->toBinary();  // string(16) "\xd9\xe7\xa1\x84\x5d\x5b\x11\xea\xa6\x2a\x34\x99\x71\x00\x62\xd0"
  456.         $uuid_base32 = $uuid->toBase32();  // string(26) "6SWYGR8QAV27NACAHMK5RG0RPG"
  457.         //$uuid_base58 = $uuid->toBase58();  // string(22) "TuetYWNHhmuSQ3xPoVLv9M"
  458.         //dd($uuidbinday);
  459.         // 34656139-3739-3566-6335-643834313038
  460.         // 4ea9795fc5d84108
  461.         //echo $id . "<br>";
  462.         //dd($uuid_binary);
  463.         // need to convert rfc4122 to binary to do the test
  464.         $User = $Repository->find($uuid_binary);
  466.         // we need, on EDIT, to set the password fields to blank
  467.         //dd($User);
  468.         $uuid_next = $Repository->getNextUserID();
  470.         //$nextUserID = $uuid_next->toBase32();
  471.         //dd($nextUserID);
  473.         $isActive = $User->getIsActive();
  474.         //dd($isActive);
  475.         if (!$User) {
  476.             throw $this->createNotFoundException('No User found for ID ' . $id);
  477.         }
  479.         $form = $this->createForm(UserType::class, $User,
  480.                         [
  481.                             'UtilityServices' => $utils,
  482.                             'generateStrongPasswordSvc' => $pwdgen,
  483.                             'editmode' => true,
  484.                             'editlabel' => 'Add User',
  485.                             'em' => $this->get('doctrine')->getManager(),
  486.                             'formstyle' => 'long',
  487.                             'nextuserid' => $uuid_next
  488.                         ]
  489.                 )
  490.                 ->add('password2', RepeatedType::class, [
  491.                     'required' => false,
  492.                     'mapped' => false,
  493.                     'invalid_message' => 'The password fields must match.',
  494.                     'type' => PasswordType::class,
  495.                     'first_options' => [
  496.                         'label' => 'Password',
  497.                         'always_empty' => true,
  498.                         'attr' => [
  499.                             "autocomplete" => "off",
  500.                             "disabled" => "disabled",
  501.                             "style" => [
  502.                                 "background-color" => "lightgray!Important"
  503.                             ]
  504.                         ]
  505.                     ],
  506.                     'second_options' => [
  507.                         'label' => 'Confirm Password',
  508.                         'always_empty' => true,
  509.                         'attr' => [
  510.                             "autocomplete" => "off",
  511.                             "disabled" => "disabled",
  512.                             "style" => [
  513.                                 "background-color" => "lightgray!Important"
  514.                             ]
  515.                         ]
  516.                     ],
  517.                     'attr' => [
  518.                         "style" => [
  519.                             "background-color" => "lightgray!Important"
  520.                         ]
  521.                     ],
  522.                 ])
  523.                 ->add('save', SubmitType::class, array('label' => 'Save'));
  525.         // Remove the password field when editing the user
  526.         // Otherwise it must be entered each time the user is edited
  527.         // We can change the password via a special edit-user-password page
  528.         $form->remove('password');
  529.         
  530.         $form->handleRequest($request);
  531.         //$errorStr = $form->getErrors();
  532.         if ($form->isSubmitted() && $form->isValid()) {
  533.             try {
  534.                 // if the user passes in a new password, change it. Otherwise just ignore the password field
  535.                 if (!empty(trim($form->get('password2')->getData()))) {
  536.                     $new_password = $form->get('password2')->getData();
  537.                     $User->setPassword(
  538.                             $passwordEncoder->encodePassword($User, $new_password)
  539.                     );
  540.                 }
  541.                 $so = $form->get('SignificantOtherID')->getData();
  542.                 if ($so) {
  543.                     $User->setSignificantOtherID($so->getID());
  544.                 } else {
  545.                     //$User->setSignificantOtherID(null);
  546.                 }
  547.                 //dd($User);
  548.                 $mp = $form->get('mobilephone')->getData();
  549.                 if ($mp) {
  550.                     $User->setMobilephone($mp);
  551.                 } else {
  552.                     $User->setMobilephone(' ');
  553.                 }
  555.                 
  557.                 $loggedInuser = $this->get('security.token_storage')->getToken()->getUser();
  558.                 $loggedinUserId = $loggedInuser->getId();
  560.                 //$User->setCreatedatuserid($uuid_base32);
  561.                 $User->setUpdatedatuserid($loggedinUserId);
  563.                 $currentdate = new \DateTime('now');
  564.                 //$User->setCreatedate($currentdate);
  565.                 $User->setLasteditdate($currentdate);
  566.                 $User->setModificationdate($currentdate);
  568.                 if (!$this->get('security.authorization_checker')->isGranted('ROLE_ADMIN') AND 
  569.                         !$this->get('security.authorization_checker')->isGranted('ROLE_ASSTADMIN')) {
  570.                     if ($isActive == true) {
  571.                         $User->setIsActive(true);
  572.                     } else {
  573.                         $User->setIsActive(false);
  574.                     }
  575.                     //echo "IsActive: ".$isActive."<br><br><br>";
  576.                     //dd($User);
  577.                 }
  578.                 
  579.                 $this->em->persist($User);
  580.                 $this->em->flush();
  581.             } catch (Exception $e) {
  582.                 $error = (string) $form->getErrors(true, false);
  583.                 $errstring = var_export($this->getErrorMessages($form), true);
  584.                 return $this->render('failure.html.twig', array(
  585.                             'error' => $error,
  586.                             ' catch' => $e->getMessage(),
  587.                             'allerrors' => $errstring));
  588.             }
  589.             // submit button pressed and any validations we had have passed the test.
  590.             // it has flushed the data back to the database so insert this form entry
  591.             // so we will now show the main page displaying our new entry at the top
  592.             //$Users = $Repository->findAll();
  593.             //$Users = $Repository->findBy([], ['lastname' => 'ASC', 'firstname' => 'ASC']);
  594.             $Users = $Repository->findAllUsersByName();
  595.             return $this->render('admin/users.html.twig', ['users' => $Users]);
  596.         } else if ($form->isSubmitted()) {
  597.             //submit button was pressed, but there is something wrong with the entry on the form
  598.             $errors = (string) $form->getErrors(true, false);
  599.             $errstring = var_export($this->getErrorMessages($form), true);
  600.             return $this->render('failure.html.twig', array(
  601.                         'errors' => $errors,
  602.                         'allerrors' => $errstring));
  603.         }
  604.         // Display the entry form
  605.         // this form should display all users, let us edit details on a user,
  606.         // return with which user and save the details
  607.         return $this->render('admin/userEdit.html.twig', ['user' => $User, 'form' => $form->createView(), 'editmode' => true]);
  608.     }
  610.     /**
  611.      * @Route("/delete/participant/{id}", name="delete_participant")
  612.      */
  613.     public function delUser(
  614.             SessionInterface $session,
  615.             PasswordServices $pwdgen,
  616.             //AuthorizationCheckerInterface $authChecker, 
  617.             UtilityServices $utils,
  618.             UserPasswordEncoderInterface $passwordEncoder,
  619.             Request $request,
  620.             $id) {
  622.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  623.             return new RedirectResponse('/login');
  624.         }
  625.         $Repository = $this->getDoctrine()->getRepository(User::class);
  627.         $User = $Repository->find($id);
  628.         $nextUserID = $Repository->getNextUserID();
  630.         if (!$User) {
  631.             throw $this - createNotFoundException('No User found for ID ' . $id);
  632.         }
  635.         $form = $this->createForm(UserType::class, $User,
  636.                         [
  637.                             'UtilityServices' => $utils,
  638.                             'generateStrongPasswordSvc' => $pwdgen,
  639.                             'editmode' => true,
  640.                             'editlabel' => 'Add User',
  641.                             'em' => $this->get('doctrine')->getManager(),
  642.                             'formstyle' => 'long',
  643.                             'nextuserid' => $nextUserID
  644.                         ]
  645.                 )
  646.                 ->add('save', SubmitType::class, [
  647.                     'label' => 'Delete',
  648.                     'attr' => array(
  649.                         'onClick' => 'return confirm("Are you sure?");',
  650.                     )
  651.                 ])
  652.                 ->add('cancel', SubmitType::class, ['label' => 'cancel'])
  653.         ;
  655.         $form->handleRequest($request);
  656.         if ($form->isSubmitted() && $form->isValid()) {
  658.             if ($form->getClickedButton() === $form->get('cancel')) {
  659.                 return $this->redirectToRoute('listparticipants');
  660.             } else {
  661.                 $this->em->remove($User);
  662.                 $this->em->flush();
  663.                 return $this->redirectToRoute('listparticipants');
  664.             }
  665.         }
  666.         return $this->render('admin/userDel.html.twig', ['form' => $form->createView()]);
  667.     }
  669.     /**
  670.      * @Route("/finduserbyemail", name="find_user_by_email")
  671.      */
  672.     public function findUserByEmail(
  673.             SessionInterface $session,
  674.             PasswordServices $pwdgen,
  675.             //AuthorizationCheckerInterface $authChecker, 
  676.             UtilityServices $utils,
  677.             UserPasswordEncoderInterface $passwordEncoder,
  678.             Request $request,
  679.     ) {
  681.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  682.             return new RedirectResponse('/login');
  683.         }
  686.         $defaultData = ['message' => 'Type your message here'];
  687.         $form = $this->createFormBuilder($defaultData)
  688.                 ->add('emails', TextType::class, ['mapped' => false])
  689.                 ->add('save', SubmitType::class, ['label' => 'Find Them',])
  690.                 ->getForm();
  692.         $form->handleRequest($request);
  694.         if ($form->isSubmitted() && $form->isValid()) {
  695.             //$data = $form->getData();
  696.             $emails = $form->get('emails')->getData();
  698.             $Repository = $this->getDoctrine()->getRepository(User::class);
  700.             $User = $Repository->findUserByEmail($emails);
  702.             return $this->render('admin/showusersemail.html.twig', ['users' => $User]);
  703.         } elseif ($form->isSubmitted() && !$form->isValid()) {
  704.             return $this->render('admin/showusersemail_failure.html.twig');
  705.         }
  707.         return $this->render('admin/finduserbyemail.html.twig', ['form' => $form->createView()]);
  708.     }
  710.     /**
  711.      * @Route("/listparticipants", name="listparticipants")
  712.      */
  713.     public function getUsers(Request $request): Response {
  714.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  715.             return new RedirectResponse('/login');
  716.         }
  717.         // https://symfony.com/doc/current/doctrine.html
  718.         //$currentdate = new \DateTime('now');
  719.         $Repository = $this->getDoctrine()->getRepository(User::class);
  721.         //$Users = $Repository->findBy([], ['lastname' => 'ASC', 'firstname' => 'ASC']);
  722.         $Users = $Repository->findAllUsersByName();
  723.         //dd($Users);
  724.         return $this->render('admin/users.html.twig', ['users' => $Users]);
  725.     }
  727.     /**
  728.      * @Route("/listparticipantsInactiveFirst", name="listparticipants_inactive_first")
  729.      */
  730.     public function getUsersInactiveFirst(Request $request): Response {
  731.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  732.             return new RedirectResponse('/login');
  733.         }
  734.         // https://symfony.com/doc/current/doctrine.html
  735.         //$currentdate = new \DateTime('now');
  736.         $Repository = $this->getDoctrine()->getRepository(User::class);
  738.         //$Users = $Repository->findBy([], ['lastname' => 'ASC', 'firstname' => 'ASC']);
  739.         $Users = $Repository->findAllUsersByNameInactiveFirst();
  740.         //dd($Users);
  741.         return $this->render('admin/users.html.twig', ['users' => $Users]);
  742.     }
  744.     /**
  745.      * @Route("/listparticipantsAllowEmailFirst", name="listparticipants_allow_email_first")
  746.      */
  747.     public function getUsersAllowEmailFirst(Request $request): Response {
  748.         if (!$this->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  749.             return new RedirectResponse('/login');
  750.         }
  751.         // https://symfony.com/doc/current/doctrine.html
  752.         //$currentdate = new \DateTime('now');
  753.         $Repository = $this->getDoctrine()->getRepository(User::class);
  755.         //$Users = $Repository->findBy([], ['lastname' => 'ASC', 'firstname' => 'ASC']);
  756.         $Users = $Repository->findAllUsersByNameAllowEmailFirst();
  757.         //dd($Users);
  758.         return $this->render('admin/users.html.twig', ['users' => $Users]);
  759.     }
  761.     /**
  762.      * @Route("/contactus", name="contactus")
  763.      */
  764.     public function contactus() {
  765.         return $this->render('security/contactus.html.twig');
  766.     }
  768.     private function getErrorMessages(\Symfony\Component\Form\Form $form) {
  769.         $errors = array();
  771.         if ($form->count() > 0) {
  772.             foreach ($form->all() as $child) {
  773.                 /**
  774.                  * @var \Symfony\Component\Form\Form $child
  775.                  */
  776.                 if (!$child->isValid()) {
  777.                     $errors[$child->getName()] = $this->getErrorMessages($child);
  778.                 }
  779.             }
  780.         } else {
  781.             /**
  782.              * @var \Symfony\Component\Form\FormError $error
  783.              */
  784.             foreach ($form->getErrors() as $key => $error) {
  785.                 $errors[] = $error->getMessage();
  786.             }
  787.         }
  789.         return $errors;
  790.     }
  792. }