src/OceanExpertBundle/Controller/ProfileController.php line 1415

Open in your IDE?
  1. <?php
  3. namespace OceanExpertBundle\Controller;
  5. use DateTime;
  6. use Doctrine\ORM\AbstractQuery;
  7. use Doctrine\ORM\Query;
  8. use Exception;
  9. use FOS\UserBundle\Mailer\MailerInterface;
  10. use FOS\UserBundle\Model\UserManagerInterface;
  11. use FOS\UserBundle\Util\TokenGeneratorInterface;
  12. use OceanExpertBundle\Entity\Indiv;
  13. use OceanExpertBundle\Entity\Institutions;
  14. use OceanExpertBundle\Entity\MemberEditsCountry;
  15. use OceanExpertBundle\Entity\MemberEditsInstitution;
  16. use OceanExpertBundle\Entity\MemberGroups;
  17. use OceanExpertBundle\Entity\ProfileImages;
  18. use OceanExpertBundle\Entity\IndivMeta;
  19. use Psr\Container\ContainerExceptionInterface;
  20. use Psr\Container\NotFoundExceptionInterface;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\RedirectResponse;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\HttpFoundation\Response;
  25. use CommerceGuys\Addressing\Model\Address;
  26. use CommerceGuys\Addressing\Formatter\DefaultFormatter;
  27. use CommerceGuys\Addressing\Repository\AddressFormatRepository;
  28. use CommerceGuys\Addressing\Repository\CountryRepository;
  29. use CommerceGuys\Addressing\Repository\SubdivisionRepository;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  32. class ProfileController extends AbstractController
  33. {
  34.     private UserManagerInterface $fosUserManager;
  35.     private TokenGeneratorInterface $fosTokenGenerator;
  36.     private MailerInterface $fosMailer;
  38.     public function __construct(
  39.         UserManagerInterface $fosUserManager,
  40.         TokenGeneratorInterface $fosTokenGenerator,
  41.         MailerInterface $fosMailer
  42.     ){
  43.         $this->fosUserManager = $fosUserManager;
  44.         $this->fosTokenGenerator = $fosTokenGenerator;
  45.         $this->fosMailer = $fosMailer;
  46.     }
  48.     /**
  49.      * @param string  $user
  50.      * @param Request $request
  51.      *
  52.      * @return Response
  53.      */
  54.     public function viewProfileAction(Request $request, string $user = ''): Response
  55.     {
  57.         //we'll need these anyhow
  58.         $eventData = '';
  59.         $adminOption = array();
  60.         $metadata = array();
  62.         $loggedUser = $this->get('security.token_storage')->getToken()->getUser();
  63.         $isLoggedIn = $this->get('security.authorization_checker')->isGranted('ROLE_USER');
  65.         if ($isLoggedIn
  66.             && $user == 'me'
  67.         ) {
  68.             //get the user id from the currently logged in user
  69.             $user = $loggedUser->getId();
  70.         } elseif (!is_numeric($user)) {
  71.             //try to find the user id by looking at the login credentials
  72.             $searchUser = $this->fosUserManager->findUserByUsername($user);
  73.             if ($searchUser) {
  74.                 $user = $searchUser->getId();
  75.             } else {
  76.                 return new Response("no idea what to do with user '$user', not found in DB");
  77.             }
  78.         }
  80.         //by now we are sure we are using the idInd
  81.         $idInd = $user;
  83.         $qb = $this->getDoctrine()
  84.             ->getManager()
  85.             ->createQueryBuilder()
  86.             ->add(
  87.                 'select',
  88.                 'indiv AS expertInfo, 
  89.                 p.name AS imageName, 
  90.                 p.path AS imagePath,
  91.                 inst.idInst,
  92.                 inst.instName,
  93.                 inst.countryCode AS instCountryCode,
  94.                 inst.state AS instState,
  95.                 inst.city AS instCity,
  96.                 inst.postcode AS instPostcode,
  97.                 inst.instAddress AS instAddr1,
  98.                 inst.addr2 AS instAddr2')
  99.             ->add(
  100.                 'from',
  101.                 'OceanExpertBundle:Indiv indiv'
  102.             )->leftJoin(
  103.                 'OceanExpertBundle:ProfileImages',
  104.                 'p',
  105.                 'WITH',
  106.                 'p.idInd = indiv.idInd'
  107.             )->leftJoin(
  108.                 'OceanExpertBundle:IndivInstitution',
  109.                 'idins',
  110.                 'WITH',
  111.                 'indiv.idInd = idins.idInd'
  112.             )->leftJoin(
  113.                 'OceanExpertBundle:Institutions',
  114.                 'inst',
  115.                 'WITH',
  116.                 'idins.idInst = inst.idInst'
  117.             )->where(
  118.                 'indiv.idInd = :userId'
  119.             )->setParameter(
  120.                 'userId',
  121.                 $idInd
  122.             );
  124.         if ($this->get('security.authorization_checker')->isGranted('ROLE_GLOBAL_EDITOR')
  125.             || ($isLoggedIn
  126.                 && $idInd == $loggedUser->getId()
  127.             )
  128.         ) {
  129.             //@todo what should be here? Arno 10/06/2021
  130.         } else {
  131.             $qb->andWhere('indiv.status = 1');
  132.         }
  134.         $expert = $qb->getQuery()
  135.             ->getResult(AbstractQuery::HYDRATE_ARRAY);
  137.         /*
  138.          * collect the data we need for the OIH JSON-LD in this array
  139.          * in the end we will need something like
  140.          * {
  141.             "@context": {
  142.                 "@vocab": "https://schema.org/"
  143.             },
  144.             "@id": "https://example.org/id/x",
  145.             "@type": "Person",
  146.             "name": "Jane Doe",
  147.             "jobTitle": "Professor",
  148.             "telephone": "(425) 123-4567",
  149.             "url": "http://www.janedoe.com",
  150.             "knowsAbout": [
  151.                 "Invasive species in brackish water",
  152.                 "https://www.wikidata.org/wiki/Q183368",
  153.                 {
  154.                   "@id": "https://example.org/id/course/x",
  155.                   "@type": "Course",
  156.                   "description": "In this course ...",
  157.                   "url": "URL to the course"
  158.                 }
  159.             ],
  160.             "identifier": {
  161.                 "@id": "https://orcid.org/0000-0002-2257-9127",
  162.                 "@type": "PropertyValue",
  163.                 "propertyID": "https://registry.identifiers.org/registry/orcid",
  164.                 "url": "https://orcid.org/0000-0002-2257-9127",
  165.                 "description": "Optional description of this record..."
  166.             }
  167.           }
  168.          */
  169.         $OIHData = array(
  170.             '@context' => array(
  171.                 '@vocab' => 'https://schema.org/'
  172.             ),
  173.             '@id' => 'https://oceanexpert.org/expert/' . $idInd,
  174.             '@type' => 'Person'
  175.         );
  177.         if (
  178.             isset($expert[0]['expertInfo'])
  179.             && is_array($expert[0]['expertInfo']))
  180.         {
  181.             //this is easier to read
  182.             foreach($expert[0] as $key => $info) {
  183.                 $expert[$key] = $info;
  184.             }
  185.             unset($expert[0]);
  187.             $em = $this->getDoctrine();
  189.             $metadata = $this->getMetaData($idInd);
  191.             $jobtype = $this->getJobTypes($idInd);
  192.             $expert['jobType'] = $jobtype['jobtype'];
  193.             //add to OIH
  194.             $jobTypes = explode('\r', $expert['jobType']);
  195.             foreach ($jobTypes as $jobType) {
  196.                 $OIHData['knowsAbout'][] = trim($jobType);
  197.             }
  199.             $expert['groups'] = $this->getUserGroups($idInd);
  201.             //make the name for OIH
  202.             //for the website this is done in the profile.html.twig template
  203.             $userNameParts = array();
  204.             foreach (array('fname','mname','sname') as $namePart) {
  205.                 if (isset($expert['expertInfo'][$namePart])
  206.                     && $expert['expertInfo'][$namePart] != ''
  207.                 ) {
  208.                     $userNameParts[] = trim($expert['expertInfo'][$namePart]);
  209.                 }
  210.             }
  211.             $OIHData['name'] = implode(' ', $userNameParts);
  213.             //what is the working location of the expert
  214.             $addressFormatRepository = new AddressFormatRepository();
  215.             $countryRepository = new CountryRepository();
  216.             $subdivisionRepository = new SubdivisionRepository();
  217.             $formatter = new DefaultFormatter(
  218.                 $addressFormatRepository,
  219.                 $countryRepository,
  220.                 $subdivisionRepository
  221.             );
  223.             $instituteAddressInfo = array();
  224.             if (array_key_exists('idInst', $expert)
  225.                 && !is_null($expert['idInst'])
  226.             ) {
  227.                 $instituteAddressInfo['addr1'] = $expert['instAddr2'];
  228.                 $instituteAddressInfo['addr2'] = $expert['instAddr1'];
  229.                 $instituteAddressInfo['postcode'] = $expert['instPostcode'];
  230.                 $instituteAddressInfo['city'] = $expert['instCity'];
  231.                 $instituteAddressInfo['state'] = $expert['instState'];
  232.                 //$instituteAddressInfo['countryCode'] = $this->getCountryFromId($expert['instCountryCode']);
  233.                 $instituteAddressInfo['countryCode'] = $this->getCountryCodeFromId($expert['instCountryCode']);
  234.             }
  236.             //dump($expert['expertInfo']);
  237.             //dump($expert['expertInfo']['countryCode']);
  238.             //dump($this->getCountryFromId($expert['expertInfo']['countryCode']));
  239.             //dump($this->getCountryCodeFromId($expert['expertInfo']['countryCode']));
  240.             //die();
  242.             if (!$expert['expertInfo']['useInstAddr']
  243.                 && isset($expert['expertInfo']['countryCode'])
  244.             ) {
  245.                 $expertAddressInfo['addr1'] = $expert['expertInfo']['addr2'];
  246.                 $expertAddressInfo['addr2'] = $expert['expertInfo']['addr1'];
  247.                 $expertAddressInfo['postcode'] = $expert['expertInfo']['postcode'];
  248.                 $expertAddressInfo['city'] =$expert['expertInfo']['city'];
  249.                 $expertAddressInfo['state'] = $expert['expertInfo']['state'];
  250.                 //$expertAddressInfo['countryCode'] = $this->getCountryFromId($expert['expertInfo']['countryCode']);
  251.                 $expertAddressInfo['countryCode'] = $this->getCountryCodeFromId($expert['expertInfo']['countryCode']);
  253.             } elseif ($expert['expertInfo']['useInstAddr']
  254.                 && isset($instituteAddressInfo['countryCode'])
  255.             ) {
  256.                 //the expert wants to use the address of the institute
  257.                 $expertAddressInfo = $instituteAddressInfo;
  258.             }
  260.             $expert['workLocation'] = 'no or invalid worklocation found';
  261.             if (isset($expertAddressInfo['countryCode'])
  262.                 && $expertAddressInfo['countryCode'] != ''
  263.                 && $expertAddressInfo['countryCode'] !== 0
  264.             ) {
  265.                 $worklocation = new Address();
  266.                 $worklocation = $worklocation
  267.                     ->withAddressLine1($expertAddressInfo['addr1'])
  268.                     ->withAddressLine2($expertAddressInfo['addr2'])
  269.                     ->withPostalCode($expertAddressInfo['postcode'])
  270.                     ->withLocality($expertAddressInfo['city'])
  271.                     ->withAdministrativeArea($expertAddressInfo['state'])
  272.                     ->withCountryCode($expertAddressInfo['countryCode']);
  274.                 try {
  275.                     $expert['workLocation'] = $formatter->format($worklocation);
  276.                 } catch (Exception $e) {
  277.                     //dump($e);
  278.                     var_dump($expertAddressInfo);
  279.                     var_dump($worklocation);
  280.                     //die();
  281.                 }
  282.                 //dump($worklocation);
  283.                 //die();
  284.             }
  286.             //make the address for OIH
  287.             //@todo must be moved after the part that defines the worklocation
  288.             $addressParts = array();
  289.             foreach (array('addr1','addr2') as $addressPart) {
  290.                 if (isset($expertAddressInfo[$addressPart])
  291.                     && $expertAddressInfo[$addressPart] != ''
  292.                 ) {
  293.                     $addressParts[] = trim($expertAddressInfo[$addressPart]);
  294.                 }
  295.             }
  296.             $OIHAddress = implode(', ', $addressParts);
  297.             if (isset($expertAddressInfo['postcode'])
  298.                 && $expertAddressInfo['postcode'] != ''
  299.             ) {
  300.                 $OIHAddress .= ', ' . $expertAddressInfo['postcode'];
  301.             }
  303.             if (isset($expertAddressInfo['city'])
  304.                 && $expertAddressInfo['city'] != ''
  305.             ) {
  306.                 $OIHAddress .= ' ' . $expertAddressInfo['city'];
  307.             }
  309.             //the $expertAddressInfo already takes the correct working location info depending on useInstAddr
  310.             $OIHLatitude = '';
  311.             $OIHLongitude = '';
  312.             if (isset($expertAddressInfo['countryCode'])
  313.                 && $expertAddressInfo['countryCode'] != ''
  314.             ) {
  315.                 $OIHCountries = $this->getCountryFromIds(
  316.                         explode(
  317.                             ',',
  318.                             $expertAddressInfo['countryCode']
  319.                         )
  320.                     );
  321.                 //we can only gave one country for the workinglocation
  322.                 $OIHAddress .= ', ' . $OIHCountries[0]['country'];
  323.                 $OIHLatitude = $OIHCountries[0]['latitude'];
  324.                 $OIHLongitude = $OIHCountries[0]['longitude'];
  326.             }
  327.             $OIHData['workLocation'] = array(
  328.                 '@type' => 'Place',
  329.                 'address' => trim($OIHAddress),
  330.                 'geo' => array(
  331.                     '@type' => 'GeoCoordinates',
  332.                     'latitude' => $OIHLatitude,
  333.                     'longitude' => $OIHLongitude
  334.                 )
  335.             );
  336.             if ($OIHLatitude != '') {
  337.                 $OIHData['workLocation']['geo']['latitude'] = $OIHLatitude;
  338.             }
  339.             if ($OIHLongitude != '') {
  340.                 $OIHData['workLocation']['geo']['longitude'] = $OIHLongitude;
  341.             }
  344.             /*
  345.                 "geo": {
  346.                     "@type": "GeoCoordinates",
  347.                     "latitude": 39.3280,
  348.                     "longitude": 120.1633
  349.                 }
  350.             */
  352.             //get the languages for OIH
  353.             //we expect
  354.             /*
  355.             "knowsLanguage": {
  356.                 "@type": "Language",
  357.                 "name": "Spanish",
  358.                 "alternateName": "es"
  360.             }
  361.             */
  362.             $allLanguages = $this->getDoctrine()
  363.                 ->getRepository('OceanExpertBundle:Languages')
  364.                 ->findAll();
  365.             //dump($allLanguages);
  366.             if (isset($expert['expertInfo']['languages'])) {
  367.                 $knowsLanguages = explode(',', $expert['expertInfo']['languages']);
  368.                 foreach ($knowsLanguages as $knowsLanguage) {
  369.                     $OIHData['knowsLanguage'][] = array(
  370.                         '@type' => 'Language',
  371.                         'name' => trim($knowsLanguage)
  372.                     );
  373.                 }
  374.             }
  376.             if (isset($expert['expertInfo']['jobtitle'])) {
  377.                 $expert['jobtitle'] = $this->getJobTypeByCodes(
  378.                     explode(
  379.                         ',',
  380.                         $expert['expertInfo']['jobtitle'])
  381.                 );
  383.                 $OIHData['jobTitle'] = trim($expert['expertInfo']['jobtitle']);
  384.             }
  386.             if (isset($expert['0']['lastEditBy'])) {
  387.                 $expert['lastEditBy'] = $this->getUpdatedBy($expert['0']['lastEditBy']);
  388.             }
  390.             if (isset($expert['0']['createdBy'])) {
  391.                 $expert['createdBy'] = $this->getUpdatedBy($expert['0']['createdBy']);
  392.             }
  394.             $expert['subjectArea'] = $this->getSubjectAreas($idInd);
  395.             if ($expert['subjectArea']
  396.                 && $expert['subjectArea'] != ''
  397.             ) {
  398.                 $subjectAreas = explode(',', $expert['subjectArea']);
  399.                 foreach ($subjectAreas as $subjectArea) {
  400.                     $OIHData['knowsAbout'][] = trim($subjectArea);
  401.                 }
  402.             }
  404.             /*
  405.              * nationality
  406.              * we expect something like
  407.              * "nationality": {
  408.                 "@type": "Country",
  409.                 "name": "Fiji",
  410.                 "identifier": {
  411.                     "@type": "PropertyValue",
  412.                     "name": "ISO 3166-1 alpha-2 code",
  413.                     "value": "FJ",
  414.                     "propertyID": [
  415.                         "https://unece.org/trade/cefact/unlocode-code-list-country-and-territory",
  416.                         "ISO 3166-1:2020"
  417.                     ]
  418.                 }
  419.         },
  420.              */
  421.             if (isset($expert['expertInfo']['idNationality'])) {
  422.                 $nationalities = $this->getCountryFromIds(
  423.                     explode(
  424.                         ',',
  425.                         $expert['expertInfo']['idNationality']
  426.                     )
  427.                 );
  429.                 foreach($nationalities as $OIHNationality) {
  430.                     $expert['nationality'][]  = trim($OIHNationality['country']);
  431.                     $OIHData['nationality'][] = array(
  432.                         '@type' => 'Country',
  433.                         'name' => trim($OIHNationality['country'])
  434.                     );
  435.                     /*
  436.                      * #808
  437.                      *
  438.                     $OIHData['nationality'][] = array(
  439.                         '@type' => 'DefinedTerm',
  440.                         'url' => 'https://unece.org/trade/cefact/unlocode-code-list-country-and-territory',
  441.                         'inDefinedTermSet' => 'UN/LOCODE Code List by Country and Territory',
  442.                         'name' => trim($OIHNationality['country']),
  443.                         'termCode' =>trim($OIHNationality['countryCode'])
  444.                     );
  445.                     */
  446.                 }
  447.                 if (isset($expert['nationality'])
  448.                     && is_array($expert['nationality'])
  449.                 ) {
  450.                     $expert['nationality'] = implode(
  451.                         ',',
  452.                         $expert['nationality']
  453.                     );
  454.                 }
  455.             }
  457.             foreach (array('url1', 'url2', 'url3') as $urlId) {
  458.                 if (isset($expert['expertInfo'][$urlId])
  459.                     && trim($expert['expertInfo'][$urlId]) != ''
  460.                 ) {
  461.                     $OIHData['url'][] = trim($expert['expertInfo'][$urlId]);
  462.                 }
  463.             }
  465.             if (isset($expert['expertInfo']['studyregion'])) {
  466.                 $expert['studyregion'] = $this->getResearchAreaByCodes(
  467.                     explode(
  468.                         ',',
  469.                         $expert['expertInfo']['studyregion']
  470.                     )
  471.                 );
  472.             }
  475.             if (isset($expert['expertInfo']['qualityCheckedBy'])) {
  476.                 $expert['qcby'] = $this->getUpdatedBy($expert['expertInfo']['qualityCheckedBy']);
  477.             }
  479.             if (isset($expert['expertInfo']['doNoInviteBy'])
  480.                 && isset($expert['expertInfo']['doNoInviteBy']) != 0
  481.             ) {
  482.                 $expert['doNoInviteBy'] = $this->getUpdatedBy($expert['expertInfo']['doNoInviteBy']);
  483.             }
  485.             if (isset($expert['expertInfo']['twitter'])) {
  486.                 $twitterUser = $expert['expertInfo']['twitter'];
  487.                 if (preg_match('/(@.+)/', $twitterUser, $matches)) {
  488.                     $twitterUser = 'https://twitter.com/' . $matches[1];
  489.                 }
  490.                 $expert['twitter'] = $twitterUser;
  491.             }
  493.             //$em->getManager()->getRepository('OceanExpertBundle:MemberGroups');
  494.             $query = $em->getManager()
  495.                 ->createQueryBuilder('m')
  496.                 ->select('m.idGroup')
  497.                 ->add('from','OceanExpertBundle:MemberGroups m')
  498.                 ->where('m.idInd =:idInd')
  499.                 ->setParameter('idInd', $idInd)
  500.                 ->getQuery();
  501.             $groups = $query->getResult();
  502.             $expert['groupids'] = array_column($groups, 'idGroup');
  503.             //$em->getRepository('OceanExpertBundle:MemberEditsCountry');
  504.             $query = $em->getManager()
  505.                 ->createQueryBuilder('m')
  506.                 ->select('m.idCountry')
  507.                 ->add('from','OceanExpertBundle:MemberEditsCountry m')
  508.                 ->where('m.idInd =:idInd')
  509.                 ->setParameter('idInd', $idInd)
  510.                 ->getQuery();
  511.             $countries = $query->getResult();
  512.             $expert['countries'] = array_column($countries, 'idCountry');
  513.             //$em->getRepository('OceanExpertBundle:MemberEditsInstitution');
  514.             $expert['canEditOwnInst'] = 0;
  515.             if (isset($expert['idInst'])) {
  516.                 $query = $em->getManager()
  517.                     ->createQueryBuilder('m')
  518.                     ->select('m')
  519.                     ->add('from','OceanExpertBundle:MemberEditsInstitution m')
  520.                     ->where('m.idInd =:idInd')
  521.                     ->andWhere('m.idInst =:idInst')
  522.                     ->setParameters(
  523.                         array(
  524.                             'idInst' => $expert['idInst'],
  525.                             'idInd' => $idInd
  526.                         )
  527.                     )
  528.                     ->getQuery();
  529.                 $canEditOwnInst = $query->getOneOrNullResult(AbstractQuery::HYDRATE_ARRAY);
  530.                 if (is_array($canEditOwnInst)
  531.                     && count($canEditOwnInst)
  532.                 ) {
  533.                     $expert['canEditOwnInst'] = 1;
  534.                 }
  535.             }
  537.             $fosUserData = $this->fosUserManager
  538.                 ->findUserBy(
  539.                     array(
  540.                         'id' => $idInd
  541.                     )
  542.                 );
  544.             if ($fosUserData) {
  545.                 $expert['roles'] = $fosUserData->getRoles();
  546.                 $expert['username'] = $fosUserData->getUsername();
  547.                 $expert['id'] = $fosUserData->getId();
  548.                 $expert['email'] = $fosUserData->getEmail();
  549.                 $userLink = $this->generateUrl(
  550.                     'view_profile',
  551.                     array(
  552.                         'user' => $expert['id']
  553.                     )
  554.                 );
  555.                 $expert['profileUrl'] = $request->getUriForPath($userLink);
  556.             }
  558.             $adminOption['countries'] = $this->getDoctrine()
  559.                 ->getRepository('OceanExpertBundle:Countries')
  560.                 ->findBy(
  561.                     [],
  562.                     ['country' => 'ASC']
  563.                 );
  565.             if (isset($expert[1]['path'])) {
  566.                 $expert['imgPath'] = $request
  567.                     ->getUriForPath('/uploads/profile/' . $expert[1]['path']);
  568.             }
  570.             $adminOption['userGroups'] = $this->getDoctrine()
  571.                 ->getRepository('OceanExpertBundle:Groups')
  572.                 ->findBy(
  573.                     [],
  574.                     ['groupname' => 'ASC']
  575.                 );
  578.             /*
  579.              * #552
  580.              * overruled by #808 and the new pattern definition
  581.              *
  582.              * we want something like this
  583.              * {
  584.                   "@id": "https://example.org/id/course/x",
  585.                   "@type": "Course",
  586.                   "description": "In this course ...",
  587.                   "url": "URL to the course"
  588.                 }
  589.              */
  590.             $OIHEventData = $this->getExpertEventParticipation(
  591.                 $idInd,
  592.                 $request
  593.             );
  595.             if ($this->container->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  596.                 $eventData =$OIHEventData;
  597.             }
  599.             foreach ($OIHEventData as $event) {
  600.                 //we only want to see the courses, not all meetings!!!!
  601.                 if ($event['idEventtype'] == 4) {
  602.                     $OIHData['knowsAbout'][] = array(
  603.                         '@id' => 'https://www.oceanexpert.org/event/' . $event['idEvent'],
  604.                         '@type' => 'Course',
  605.                         'description' => $event['title'],
  606.                         'url' => 'https://www.oceanexpert.org/event/' . $event['idEvent'],
  607.                         'endDate' => $event['endOn'],
  608.                         'startDate' => $event['startOn']
  609.                     );
  610.                 }
  611.             }
  613.             if (isset($metadata['orcid'])
  614.                 && $metadata['orcid'] != ''
  615.             ) {
  616.                 $OIHData['identifier'][] = array(
  617.                     '@id' => $metadata['orcid'],
  618.                     '@type' => 'PropertyValue',
  619.                     'propertyID' => 'https://registry.identifiers.org/registry/orcid',
  620.                     'url' => 'https://orcid.org/' . $metadata['orcid']
  621.                 );
  622.             }
  624.             if (isset($metadata['researcherid'])
  625.                 && $metadata['researcherid'] != ''
  626.             ) {
  627.                 $OIHData['identifier'][] = array(
  628.                     '@id' => $metadata['researcherid'],
  629.                     '@type' => 'PropertyValue',
  630.                     'propertyID' => 'https://www.researcherid.com',
  631.                     'url' => 'https://www.researcherid.com/' . $metadata['researcherid']
  632.                 );
  633.             }
  635.             if (isset($metadata['researcharea'])
  636.                 && $metadata['researcharea'] != ''
  637.             ) {
  638.                 $researchArea = str_replace('\r', ', ' , $metadata['researcharea']);
  639.                 $researchArea = str_replace('  ', ' ' , $researchArea);
  640.                 $OIHData['knowsAbout'][] = $researchArea;
  641.             }
  642.         }  else {
  643.             //we did not find user info
  644.             //this can be a new profile
  645.             //check if we can find login credentials
  646.             $searchUser = $this->fosUserManager
  647.                 ->findUserBy(
  648.                     array(
  649.                         'id' => $idInd
  650.                     )
  651.                 );
  653.             //we found credentials
  654.             //only show info for global editors or for the user himself
  655.             //else the profile data can never be completed
  656.             if (!null == $searchUser
  657.                 && ($this->get('security.authorization_checker')->isGranted('ROLE_GLOBAL_EDITOR'))
  658.                 || ($isLoggedIn
  659.                     && ($idInd == $loggedUser->getId())
  660.                 )
  661.             ) {
  662.                 $expert['expertInfo']['idInd'] = $idInd;
  663.                 $expert['username'] = $searchUser->getUsername();
  664.                 $expert['error'] = 'Incomplete Profile.';
  665.             } else {
  666.                 $expert = array(
  667.                     'error' => 'User not found.'
  668.                 );
  669.             }
  670.         }
  672.         $OIHData = json_encode(
  673.             $OIHData,
  674.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK
  675.         );
  677.         //dump($expert);
  678.         return $this->render(
  679.             'Profile/profile.html.twig',
  680.             array(
  681.                 'OIHData' => $OIHData,
  682.                 'expert' => $expert,
  683.                 'metadata' => $metadata,
  684.                 'adminOption' => $adminOption,
  685.                 'eventData' => $eventData
  686.             )
  687.         );
  688.     }
  690.     /**
  691.      * get the data of an expert to show on the profile page
  692.      *
  693.      * @param Request $request
  694.      *
  695.      * @return Response
  696.      *
  697.      * @throws ContainerExceptionInterface
  698.      * @throws NotFoundExceptionInterface
  699.      *
  700.      * @todo fix missing $data
  701.      *
  702.      */
  703.     public function userProfileAction(Request $request): Response
  704.     {
  705.         $data = $request->request->all();
  707.         $username = '';
  708.         if ($this->container->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  709.             $username = $this->get('security.token_storage')->getToken()->getUser()->getUsername();
  710.         }
  712.         if (!isset($data['userEmail'])) {
  713.             if ($username !== '') {
  714.                 return $this->redirect('expert/' . $username);
  715.             } else {
  716.                 //no such user, strange...
  717.                 $message = "Cannot find user without email address and without username.";
  718.                 return $this->render(
  719.                     'Exception/error.html.twig',
  720.                     array(
  721.                         'message' => $message
  722.                     )
  723.                 );
  724.             }
  725.         }
  727.         //this should have been checked before
  728.         //but better be safe than sorry
  729.         $data['userEmail'] = filter_var(
  730.             $data['userEmail'],
  731.             FILTER_SANITIZE_EMAIL
  732.         );
  734.         $userId = $this->fosUserManager->findUserByEmail($data['userEmail'])->getId();
  735.         unset($data['_wysihtml5_mode']);
  736.         $data = array_filter($data);
  737.         if (isset($data['researcharea'])) {
  738.             $data['research'] = $this->getResearchAreaByCodes($data['researcharea']);
  739.         }
  740.         if (isset($data['studyregion'])) {
  741.             $data['study'] = $this->getResearchAreaByCodes($data['studyregion']);
  742.         } else {
  743.             $data['studyregion'] = array();
  744.         }
  746.         if (null !== ($data['country'])) {
  747.             $data['countryName'] = $this->getCountryByCode($data['country']);
  748.         }
  749.         if (null !== ($data['jobtype'])) {
  750.             $data['job'] = $this->getJobTypeByCodes($data['jobtype']);
  751.         }
  752.         if ($data['regType'] == '1') {
  753.             $data['type'] = "Organization";
  754.         } else {
  755.             $data['type'] = "Personal";
  756.             $data['country'] = $data['country2'];
  757.             $data['locality'] = isset($data['city2']) ? $data['city2'] : '';
  758.             $data['administrative_area_level_1'] = isset($data['state2']) ? $data['state2'] : '';
  759.             $data['postal_code'] = isset($data['postcode2']) ? $data['postcode2'] : '';
  760.             $data['box'] = isset($data['box2']) ?: '';
  761.             $data['route'] = isset($data['address2']) ? $data['address2'] : '';
  762.             $data['addrline2'] = isset($data['addrline2']) ? $data['addrline2'] : '';
  764.         }
  765.         if (null !== $request->files->get('file')) {
  766.             $file = $request->files->get('file');
  767.             $filetype = $request->files->get('file')->guessClientExtension();
  768.             $filename = "profile_" . $userId . "." . $filetype;
  769.             $em = $this->getDoctrine()->getManager();
  770.             $item = $em->getRepository('OceanExpertBundle:ProfileImages')->findOneBy(array('idInd' => $userId));
  771.             if ($item) {
  772.                 $item->setFile($file);
  773.                 $item->setName($filename);
  774.                 $item->setPath($filename);
  775.                 $item->upload();
  776.                 $em->persist($item);
  777.                 $em->flush();
  778.                 $data['profileId'] = $item->getId();
  779.             } else {
  780.                 $profile = new ProfileImages();
  781.                 $profile->setFile($file);
  782.                 $profile->setName($filename);
  783.                 $profile->setPath($filename);
  784.                 $profile->setIdInd($userId);
  785.                 $profile->upload();
  786.                 $em->persist($profile);
  787.                 $em->flush();
  788.                 if ($profile) {
  789.                     $data['profileId'] = $profile->getId();
  790.                 }
  791.             }
  792.         }
  794.         try {
  796.             /*
  797.              * this is incorrect
  798.              * see also#659
  799.              *
  800.             $privateaddress = isset($data['route'])?trim($data['route']) . '<br />':'';
  801.             $privateaddress .= isset($data['addrline2'])?trim($data['addrline2']) . '<br />':'';
  802.             $privateaddress .= isset($data['postal_code'])?trim($data['postal_code']).", ":'';
  803.             $privateaddress .= isset($data['locality'])?trim($data['locality']).", ":'';
  804.             $privateaddress .= isset($data['administrative_area_level_1'])?trim($data['administrative_area_level_1']) . '<br />':'';
  805.             $privateaddress .= isset($data['country'])?trim($this->getCountryByCode($data['country'])) . '<br />':'';
  806.             */
  808.             $indiv = new Indiv();
  809.             $indiv->setTitle(isset($data['title']) ? $data['title'] : '');
  810.             $indiv->setFname(isset($data['firstname']) ? $data['firstname'] : '');
  811.             $indiv->setMname(isset($data['middlename']) ? $data['middlename'] : '');
  812.             $indiv->setSname(isset($data['lastname']) ? $data['lastname'] : '');
  813.             $indiv->setRegType(isset($data['reg-type']) ? $data['reg-type'] : '');
  814.             $indiv->setIdentifier('');
  815.             $indiv->setUseInstAddr(isset($data['useinstaddress']) ? $data['useinstaddress'] : 0);
  816.             /*
  817.              * this is incorrect
  818.              * see also#659
  819.              */
  820.             $indiv->setPrivateAddress('');
  821.             $indiv->setCity(isset($data['locality']) ? $data['locality'] : '');
  822.             $indiv->setAddr1(isset($data['route']) ? $data['route'] : '');
  823.             $indiv->setAddr2(isset($data['addrline2']) ? $data['addrline2'] : '');
  824.             $indiv->setState(isset($data['administrative_area_level_1']) ? $data['administrative_area_level_1'] : '');
  825.             $indiv->setPostcode(isset($data['postal_code']) ? $data['postal_code'] : '');
  826.             $indiv->setCountryCode(isset($data['country']) ? $data['country'] : '');
  827.             $indiv->setIDNationality(isset($data['id_nationality']) ? $data['id_nationality'] : 0);
  828.             $indiv->setGender(isset($data['gender']) ? $data['gender'] : '');
  829.             $indiv->setTel(isset($data['phone']) ? $data['phone'] : '');
  831.             //we are already in a condition where we are sure the $data['userEmail'] exists
  832.             //and is well-formed
  833.             $indiv->setEmail1($data['userEmail']);
  835.             if (isset($data['alternateEmail'])
  836.                 && $data['alternateEmail'] !== ''
  837.                 && filter_var($data['alternateEmail'], FILTER_VALIDATE_EMAIL)
  838.             ) {
  839.                 $data['alternateEmail'] = filter_var(
  840.                     $data['alternateEmail'],
  841.                     FILTER_SANITIZE_EMAIL
  842.                 );
  843.             } else {
  844.                 $data['alternateEmail'] = '';
  845.             }
  846.             $indiv->setEmail2($data['alternateEmail']);
  847.             $indiv->setEmail3(isset($data['']) ? $data[''] : '');
  848.             $indiv->setUrl1(isset($data['website-personal']) ? $data['website-personal'] : '');
  849.             $indiv->setUrl2(isset($data['website-institution']) ? $data['website-institution'] : '');
  850.             $indiv->setLinkedin(isset($data['linkedin']) ? $data['linkedin'] : '');
  851.             $indiv->setFacebook(isset($data['facebook']) ? $data['facebook'] : '');
  852.             $indiv->setTwitter(isset($data['twitter']) ? $data['twitter'] : '');
  853.             $indiv->setOther(isset($data['other']) ? $data['other'] : '');
  854.             $indiv->setDegree(isset($data['degree']) ? $data['degree'] : '');
  855.             $indiv->setJobtitle(isset($data['job']) ? $data['job'] : '');
  856.             $indiv->setDept(isset($data['department']) ? $data['department'] : '');
  857.             $indiv->setStudyregion(isset($data['study']) ? $data['study'] : '');
  858.             $indiv->setLanguages(implode(',', $data['languages']));
  859.             $indiv->setComments(isset($data['comments']) ? $data['comments'] : '');
  860.             $indiv->setSkills(isset($data['skills']) ? $data['skills'] : '');
  861.             $indiv->setIdImagefile(isset($data['profileId']) ? $data['profileId'] : null);
  862.             $indiv->setFDateEnt(new DateTime('now'));
  863.             $indiv->setLDateUpd(new DateTime('now'));
  864.             $indiv->setCreatedBy(isset($data['']) ? $data[''] : 0);
  865.             $indiv->setLastEditBy(isset($data['']) ? $data[''] : 0);
  866.             $indiv->setFax(isset($data['']) ? $data[''] : '');
  867.             $indiv->setUrl3(isset($data['']) ? $data[''] : '');
  868.             $indiv->setUrlsChecked(new DateTime('now'));
  869.             $indiv->setFlickr(isset($data['']) ? $data[''] : '');
  870.             $indiv->setActiveng(isset($data['']) ? $data[''] : '');
  871.             $indiv->setActivother(isset($data['']) ? $data[''] : '');
  872.             $indiv->setDoNotInvite(isset($data['']) ? $data[''] : 0);
  873.             $indiv->setAdminComments(isset($data['']) ? $data[''] : '');
  874.             $indiv->setIsGlobal(isset($data['']) ? $data[''] : 0);
  875.             $indiv->setStatus(isset($data['']) ? $data[''] : 0);
  876.             $indiv->setStatusLastChanged(new DateTime());
  877.             $indiv->setDeceased(isset($data['']) ? $data[''] : 0);
  878.             $indiv->setRetired(isset($data['']) ? $data[''] : 0);
  880.             $em = $this->getDoctrine()->getManager();
  881.             $em->persist($indiv); //marks object to be saved in the next transaction.
  882.             $em->flush(); //performs all saves and transactions.
  883.             if (!isset($data['orcid'])) {
  884.                 $data['orcid'] = '';
  885.             }
  886.             if (!isset($data['researcherid'])) {
  887.                 $data['researcherid'] = '';
  888.             }
  889.             if (!isset($data['google-scholar'])) {
  890.                 $data['google-scholar'] = '';
  891.             }
  892.             if (!isset($data['researchgate'])) {
  893.                 $data['researchgate'] = '';
  894.             }
  895.             if (!isset($data['others'])) {
  896.                 $data['others'] = '';
  897.             }
  898.             if (!isset($data['researcharea'])) {
  899.                 $data['researcharea'] = array();
  900.             }
  902.             if ($indiv->getIdInd()) {
  903.                 $usermeta = array(
  904.                     'orcid' => $data['orcid'],
  905.                     'researcherid' => $data['researcherid'],
  906.                     'researcharea' => implode(', ', $data['researcharea']),
  907.                     'google-scholar' => $data['google-scholar'],
  908.                     'researchgate' => $data['researchgate'],
  909.                     'others' => $data['others']
  910.                 );
  911.                 $usermeta = array_filter($usermeta);
  913.                 foreach ($usermeta as $key => $value) {
  914.                     $chkmeta = $em->getRepository('OceanExpertBundle:IndivMeta')
  915.                         ->findOneBy(
  916.                             array(
  917.                                 'indivId' => $indiv->getIdInd(),
  918.                                 'metaOption' => $key
  919.                             )
  920.                         );
  922.                     if ($chkmeta) {
  923.                         $chkmeta->setMetaValue($value);
  924.                         $em->persist($chkmeta);
  925.                         $em->flush();
  926.                     } else {
  927.                         $meta = new IndivMeta();
  928.                         $meta->setIndivId($indiv->getIdInd());
  929.                         $meta->setMetaOption($key);
  930.                         $meta->setMetaValue($value);
  931.                         $em = $this->getDoctrine()->getManager();
  932.                         $em->persist($meta);
  933.                         $em->flush();
  934.                     }
  935.                 }
  936.             }
  937.         } catch (Exception $e) {
  938.             //return error message
  939.             $message = $e->getMessage();
  940.             return $this->render(
  941.                 'Exception/error.html.twig',
  942.                 array(
  943.                     'message' => $message
  944.                 )
  945.             );
  946.         }
  948.         return $this->redirect(
  949.             $this->generateUrl(
  950.                 'profile_status'
  951.             )
  952.         );
  953.     }
  955.     /**
  956.      * edit an existing user profile
  957.      *
  958.      * @param int|null $userId the id of the profile to edit
  959.      *
  960.      * @return Response
  961.      *
  962.      * @throws \Psr\Container\ContainerExceptionInterface
  963.      * @throws \Psr\Container\NotFoundExceptionInterface
  964.      */
  965.     public function editAction(int $userId = null): Response
  966.     {
  967.         //only logged-in users can get the right to edit
  968.         //this is only a first check (see #493)
  969.         if (!$this->get('security.authorization_checker')->isGranted('ROLE_USER')) {
  970.             $url = $this->container->get('router')->generate('frontend_homepage');
  971.             return new RedirectResponse($url);
  972.         }
  974.         //we will always need to know the current user to be sure that not everybody can change another account
  975.         $user = $this->get('security.token_storage')->getToken()->getUser();
  977.         if ($userId == '') {
  978.             //this is the simplest case
  979.             //no userid is given so edit the profile from the person that is logged in
  980.             $userId = $user->getId();
  981.         }
  983.         //we want to edit an existing user, so this user must have an entry in the fos_user db
  984.         $fosUserData = $this->fosUserManager
  985.             ->findUserBy(
  986.                 array(
  987.                     'id'=>$userId
  988.                 )
  989.             );
  990.         if (!$fosUserData) {
  991.             //no such user, strange...
  992.             $message = "There is no user with this id ($userId).";
  993.             return $this->render(
  994.                 'Exception/error.html.twig',
  995.                 array(
  996.                     'message' => $message
  997.                 )
  998.             );
  999.         }
  1001.         //here it gets tricky
  1002.         //who can edit, what profile??
  1003.         if ($userId == $user->getId() //no problem, everybody can adapt his/here own profile
  1004.             || $this->get('security.authorization_checker')->isGranted('ROLE_ADMIN')) //no problem, admin users can change the profiles of others
  1005.         {
  1006.             $em = $this->getDoctrine()->getManager();
  1007.             $indiv =  $this->getDoctrine()
  1008.                 ->getRepository('OceanExpertBundle:Indiv')
  1009.                 ->findOneByIdInd($userId);
  1010.             if(!$indiv) {
  1011.                 //create a new profile as it does not exist yet
  1012.                 //this happens when people subscribe and want to complete their profile
  1014.                 $indiv = new Indiv();
  1015.                 $indiv->setTitle('');
  1016.                 $indiv->setFname('');
  1017.                 $indiv->setMname('');
  1018.                 $indiv->setSname('');
  1019.                 $indiv->setIdentifier('');
  1020.                 $indiv->setRegType('');
  1021.                 $indiv->setUseInstAddr(0);
  1022.                 $indiv->setPrivateAddress('');
  1023.                 $indiv->setAddr1('');
  1024.                 $indiv->setAddr2('');
  1025.                 $indiv->setCity('');
  1026.                 $indiv->setState('');
  1027.                 $indiv->setPostcode('');
  1028.                 $indiv->setIdNationality('');
  1029.                 $indiv->setTel('');
  1030.                 $indiv->setFax('');
  1031.                 $indiv->setEmail2('');
  1032.                 $indiv->setEmail3('');
  1033.                 $indiv->setUrl1('');
  1034.                 $indiv->setUrl2('');
  1035.                 $indiv->setUrl3('');
  1036.                 $indiv->setGender('');
  1037.                 $indiv->setLinkedin('');
  1038.                 $indiv->setFacebook('');
  1039.                 $indiv->setFlickr('');
  1040.                 $indiv->setTwitter('');
  1041.                 $indiv->setOther('');
  1042.                 $indiv->setDegree('');
  1043.                 $indiv->setActiveng('');
  1044.                 $indiv->setActivother('');
  1045.                 $indiv->setJobtitle('');
  1046.                 $indiv->setDept('');
  1047.                 $indiv->setStudyregion('');
  1048.                 $indiv->setLanguages('');
  1049.                 $indiv->setSkills('');
  1050.                 $indiv->setComments('');
  1051.                 $indiv->setDoNotInvite('');
  1052.                 $indiv->setAdminComments('');
  1053.                 $indiv->setIsGlobal(1);
  1054.                 $indiv->setStatus(0);
  1055.                 $indiv->setDeceased(0);
  1056.                 $indiv->setRetired(0);
  1057.                 $indiv->setIdInd($userId);
  1058.                 $indiv->setCountryCode(21);
  1060.                 //check email again and again
  1061.                 $fosUserEmail = $fosUserData->getEmail();
  1062.                 if (filter_var( $fosUserEmail, FILTER_VALIDATE_EMAIL)) {
  1063.                     $fosUserEmail = filter_var(
  1064.                         $fosUserEmail,
  1065.                         FILTER_SANITIZE_EMAIL
  1066.                     );
  1067.                 } else {
  1068.                     $message = "this ($fosUserEmail) is not a valid email address";
  1069.                     return $this->render(
  1070.                         'Exception/error.html.twig',
  1071.                         array(
  1072.                             'message' => $message
  1073.                         )
  1074.                     );
  1075.                 }
  1076.                 $indiv->setEmail1($fosUserEmail);
  1078.                 $em->persist($indiv);
  1079.                 $em->flush();
  1080.             }
  1081.         } else {
  1082.             //this is not correct #491
  1083.             $message = 'You do not have the correct rights (your are not this person and you are not an admin user) to edit this profile.';
  1084.             return $this->render(
  1085.                 'Exception/error.html.twig',
  1086.                 array(
  1087.                     'message' => $message
  1088.                 )
  1089.             );
  1090.         }
  1092.         $qb = $this->getDoctrine()
  1093.             ->getManager()
  1094.             ->createQueryBuilder();
  1096.         $qb->add('select', 'i, ins, p, c')
  1097.             ->add('from', 'OceanExpertBundle:Indiv i')
  1098.             ->leftJoin('OceanExpertBundle:ProfileImages', 'p', 'WITH', 'p.idInd = i.idInd')
  1099.             ->leftJoin('OceanExpertBundle:IndivInstitution', 'idins', 'WITH', 'i.idInd = idins.idInd')
  1100.             ->leftJoin('OceanExpertBundle:Institutions', 'ins', 'WITH', 'idins.idInst = ins.idInst')
  1101.             ->leftJoin('OceanExpertBundle:Countries', 'c', 'WITH', 'c.idCountry = i.countryCode')
  1102.             ->where('i.idInd = :userId')
  1103.             ->setParameter('userId', $userId);
  1105.         //get the expert data as far as we can find it
  1106.         $expert = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1107.         //dump($expert);
  1108.         //die();
  1110.         $metadata = $this->getMetaData($userId);
  1111.         $jobType = $this->getJobTypes($userId);
  1113.         $expert['jobType'] = $jobType['jobId'];
  1114.         $expert['userId'] = $userId;
  1115.         $expert['subjectArea'] = $this->getSubjectAreas($userId);
  1116.         $expert['roles'] = $fosUserData->getRoles();
  1117.         $expert['username'] = $fosUserData->getUsername();
  1118.         $expert['email'] = $fosUserData->getEmail();
  1120.         //get some data for the rest of the form
  1121.         $countries = $this->getDoctrine()
  1122.             ->getRepository('OceanExpertBundle:Countries')
  1123.             ->findBy(
  1124.                 [],
  1125.                 ['country' => 'ASC']
  1126.             );
  1127.         $locales = $this->getDoctrine()
  1128.             ->getRepository('OceanExpertBundle:Locale')
  1129.             ->findBy(
  1130.                 [],
  1131.                 ['locale' => 'ASC']
  1132.             );
  1133.         $studyregions = $this->getDoctrine()
  1134.             ->getRepository('OceanExpertBundle:Regions')
  1135.             ->findBy(
  1136.                 [],
  1137.                 ['name' => 'ASC']
  1138.             );
  1139.         $instituteSeaRegion = $this->getDoctrine()
  1140.             ->getRepository('OceanExpertBundle:Regions')
  1141.             ->seaRegions();
  1142.         $allSubjects = $this->getDoctrine()
  1143.             ->getRepository('OceanExpertBundle:Subjects')
  1144.             ->findBy(
  1145.                 [],
  1146.                 ['subname' => 'ASC']
  1147.             );
  1148.         $allJobtypes = $this->getDoctrine()
  1149.             ->getRepository('OceanExpertBundle:Jobtypes')
  1150.             ->findBy(
  1151.                 [],
  1152.                 ['idJob' => 'ASC']
  1153.             );
  1155.         //dump($expert);
  1156.         //die();
  1157.         return $this->render('Profile/editProfile.html.twig', array(
  1158.             'expert' => $expert,
  1159.             'countries' => $countries,
  1160.             'locales' => $locales,
  1161.             //is not used
  1162.             //'nationalities' => $countries,
  1163.             'metadata' => $metadata,
  1164.             'studyregions' => $studyregions,
  1165.             'availableSeaRegions' => $instituteSeaRegion,
  1166.             'allSubjects' => $allSubjects,
  1167.             'allJobtypes' => $allJobtypes
  1168.         ));
  1169.     }
  1171.     public function updateProfileTimeAction(Request $request): Response
  1172.     {
  1173.         $security_context = $this->get('security.authorization_checker');
  1174.         if ($security_context->isGranted('ROLE_USER')) {
  1175.             $userId = $request->request->get('userId');
  1176.             if ($userId) {
  1177.                 $indiv = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($userId);
  1178.                 if ($indiv) {
  1179.                     $indiv->setLDateUpd(new DateTime('now'));
  1180.                     $indiv->setLastEditBy($security_context->getToken()->getUser()->getId());
  1181.                     $em = $this->getDoctrine()->getManager();
  1182.                     $em->persist($indiv); //marks object to be saved in the next transaction.
  1183.                     $em->flush(); //performs all saves and transactions.
  1184.                 }
  1185.                 return new Response("updated successfully");
  1186.             } else {
  1187.                 return new Response("cannot update");
  1188.             }
  1189.         }
  1190.         return new Response("cannot update");
  1191.     }
  1193.     /**
  1194.      * activate the user with the given id
  1195.      *
  1196.      * @param int $userId
  1197.      *
  1198.      * @return JsonResponse
  1199.      */
  1200.     public function activateUserAction(int $userId): JsonResponse
  1201.     {
  1202.         $security_context = $this->get('security.authorization_checker');
  1204.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1205.             if ($userId) {
  1206.                 $indiv = $this->getDoctrine()
  1207.                     ->getRepository('OceanExpertBundle:Indiv')
  1208.                     ->findOneByIdInd($userId);
  1209.                 if ($indiv) {
  1210.                     $indiv->setStatus(1);
  1211.                     $indiv->setStatusLastChanged(new DateTime('now'));
  1212.                     $em = $this->getDoctrine()->getManager();
  1213.                     $em->persist($indiv); //marks object to be saved in the next transaction.
  1214.                     $em->flush(); //performs all saves and transactions.
  1215.                 }
  1216.                 return new JsonResponse(
  1217.                     array(
  1218.                         'status' => true,
  1219.                         'msg' => "updated successfully"
  1220.                     )
  1221.                 );
  1222.             } else {
  1223.                 return new JsonResponse(
  1224.                     array(
  1225.                         'status' => false,
  1226.                         'msg' => "cannot update"
  1227.                     )
  1228.                 );
  1229.             }
  1230.         }
  1231.         return new JsonResponse(
  1232.             array(
  1233.                 'status' => false,
  1234.                 'msg' => "you do not have sufficient privileges to perform this action"
  1235.             )
  1236.         );
  1237.     }
  1239.     /**
  1240.      * deactivate the user with the given id
  1241.      *
  1242.      * @param int $userId
  1243.      *
  1244.      * @return Response
  1245.      */
  1246.     public function deactivateUserAction($userId): Response
  1247.     {
  1248.         if (!$userId
  1249.             || $userId == ''
  1250.             || !is_numeric($userId)
  1251.         ) {
  1252.             $message[] = array(
  1253.                 'id' => $userId,
  1254.                 'status' => 0,
  1255.                 'message' => 'incorrect or no user id given'
  1256.             );
  1257.         }
  1258.         $userId = intval($userId);
  1260.         $security_context = $this->get('security.authorization_checker');
  1261.         $message = array();
  1263.         $authorId = $this->get('security.token_storage')
  1264.                 ->getToken()
  1265.                 ->getUser()
  1266.                 ->getId();
  1268.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')
  1269.             || $userId === $authorId
  1270.         ) {
  1272.             $em = $this->getDoctrine()->getManager();
  1274.             //disable the login
  1275.             $FOSUser = $em
  1276.                 ->getRepository('OceanExpertBundle:FosUser')
  1277.                 ->findOneById($userId);
  1278.             if ($FOSUser) {
  1279.                 $FOSUser->setEnabled(0);
  1280.                 $FOSUser->setUpdatedAt(new DateTime('now'));
  1281.                 $em->persist($FOSUser);
  1282.                 $em->flush();
  1283.             } else {
  1284.                 $message[] = array(
  1285.                     'id' => $userId,
  1286.                     'status' => 0,
  1287.                     'message' => "no user found in fos_user table with id $userId"
  1288.                 );
  1289.             }
  1291.             //deactivate the expert
  1292.             $indiv = $em
  1293.                 ->getRepository('OceanExpertBundle:Indiv')
  1294.                 ->findOneByIdInd($userId);
  1295.             if ($indiv) {
  1296.                 $comments = $indiv->getComments() . "this user($userId) has been deactivated by user with id $authorId ";
  1297.                 $indiv
  1298.                     ->setStatus(3)
  1299.                     ->setComments($comments)
  1300.                     ->setStatusLastChanged(new DateTime('now'));
  1301.                 $em->persist($indiv); //marks object to be saved in the next transaction.
  1302.                 $em->flush(); //performs all saves and transactions.
  1303.             } else {
  1304.                 $message[] = array(
  1305.                     'id' => $userId,
  1306.                     'status' => 0,
  1307.                     'message' => "no user found in indiv table with idInd $userId"
  1308.                 );
  1309.             }
  1311.             if (!count($message)) {
  1312.                 //no error messages yet so all should be fine
  1313.                 $message[] = array(
  1314.                     'id' => $userId,
  1315.                     'status' => true,
  1316.                     'message' => "user with idInd $userId deactivated"
  1317.                 );
  1318.             }
  1319.         } else {
  1320.             $message[] = array(
  1321.                 'id' => $userId,
  1322.                 'status' => 0,
  1323.                 'message' => 'you do not have enough rights to do this'
  1324.             );
  1325.         }
  1327.         return new JsonResponse($message);
  1328.     }
  1330.     public function getNationalityFromId($id)
  1331.     {
  1332.         $em = $this->getDoctrine()->getRepository('OceanExpertBundle:Nationality')->findOneById($id);
  1333.         if ($em == null) {
  1334.             return false;
  1335.         } else {
  1336.             return $em->getNationality();
  1337.         }
  1338.     }
  1340.     public function getCountryFromId($id)
  1341.     {
  1342.         $em = $this->getDoctrine()->getRepository('OceanExpertBundle:Countries')->findOneByIdCountry($id);
  1343.         if ($em == null) {
  1344.             return false;
  1345.         } else {
  1346.             return $em->getCountry();
  1347.         }
  1348.     }
  1350.     public function getCountryCodeFromId($id)
  1351.     {
  1352.         $em = $this->getDoctrine()
  1353.             ->getRepository('OceanExpertBundle:Countries')
  1354.             ->findOneByIdCountry($id);
  1355.         if ($em == null) {
  1356.             return false;
  1357.         } else {
  1358.             return $em->getCountryCode();
  1359.         }
  1360.     }
  1363.     /**
  1364.      * get the country info for the given id's or country codes
  1365.      *
  1366.      * @param array $countryArr
  1367.      *
  1368.      * @return array
  1369.      */
  1370.     public function getCountryFromIds(array $countryArr): array
  1371.     {
  1372.         $em = $this->getDoctrine()
  1373.             ->getRepository('OceanExpertBundle:Countries');
  1374.         $query = $em->createQueryBuilder('c')
  1375.             ->select('c.country, c.countryCode, c.longitude, c.latitude')
  1376.             ->where('c.idCountry in (:idCountry)')
  1377.             ->orWhere('c.countryCode in (:idCountry)')
  1378.             ->setParameter('idCountry', $countryArr)
  1379.             ->getQuery();
  1381.         return $query->getResult();
  1382.     }
  1385.     /**
  1386.      * @todo is this used???? Arno 06/09/24
  1387.      *
  1388.      * @param $value
  1389.      *
  1390.      * @return string
  1391.      */
  1392.     /*
  1393.     public function csvComma($value = '')
  1394.     {
  1396.         return "'" . implode("','", explode(",", $value)) . "'";
  1397.     }
  1398.     */
  1400.     public function getJobTypeByCodes($jobArr)
  1401.     {
  1402.         $em = $this->getDoctrine()
  1403.             ->getRepository('OceanExpertBundle:Jobtypes');
  1404.         $query = $em->createQueryBuilder('a')
  1405.             ->select('a.jobname')
  1406.             ->where('a.idJob in (:jobArr)')
  1407.             ->setParameter('jobArr', $jobArr)
  1408.             ->getQuery();
  1410.         $jobs = $query->getResult();
  1411.         $jobList = array_column($jobs, 'jobname');
  1412.         return implode(', ', $jobList);
  1413.     }
  1415.     public function getResearchAreaByCodes($codeArr)
  1416.     {
  1417.         $em = $this->getDoctrine()
  1418.             ->getRepository('OceanExpertBundle:Regions');
  1419.         $query = $em->createQueryBuilder('a')
  1420.             ->select('a.name')
  1421.             ->where('a.idRegion in (:codeArr)')
  1422.             ->setParameter('codeArr', $codeArr)
  1423.             ->getQuery();
  1425.         $regions = $query->getResult();
  1426.         $regionsList = array_column($regions, 'name');
  1427.         return implode(', ', $regionsList);
  1428.     }
  1430.     /**
  1431.      * get all the meta data for a given userId
  1432.      * this data comes as a key-value pair
  1433.      *
  1434.      * @param int $userId the userId of the expert
  1435.      *
  1436.      * @return array
  1437.      */
  1438.     public function getMetaData(int $userId): array
  1439.     {
  1440.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1441.         $qb->add('select', 'm.metaOption,m.metaValue')
  1442.             ->add('from', 'OceanExpertBundle:IndivMeta m')
  1443.             ->where('m.indivId = :userId')
  1444.             ->setParameter('userId', $userId);
  1446.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1447.         $metadata = array();
  1448.         foreach ($meta as $value) {
  1449.             $metadata[$value['metaOption']] = $value['metaValue'];
  1450.         }
  1451.         return $metadata;
  1452.     }
  1454.     /**
  1455.      * get all the different job types for a given userId
  1456.      *
  1457.      * @param int $userId the userId of the expert
  1458.      *
  1459.      * @return array
  1460.      */
  1461.     public function getJobTypes(int $userId): array
  1462.     {
  1463.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1464.         $qb->add('select', 'jt.jobname,jt.idJob')
  1465.             ->add('from', 'OceanExpertBundle:IndivJobtype j')
  1466.             ->leftJoin('OceanExpertBundle:Jobtypes', 'jt', 'WITH', 'jt.idJob = j.idJob')
  1467.             ->where('j.idInd = :userId')
  1468.             ->setParameter('userId', $userId);
  1470.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1471.         $jobTypes = implode(
  1472.             '\r',
  1473.             array_column(
  1474.                 $meta,
  1475.                 'jobname'
  1476.             )
  1477.         );
  1478.         $jobId = implode(
  1479.             ',',
  1480.             array_column(
  1481.                 $meta,
  1482.                 'idJob'
  1483.             )
  1484.         );
  1485.         return array(
  1486.             'jobtype' => $jobTypes,
  1487.             'jobId' => $jobId
  1488.         );
  1489.     }
  1491.     public function getUserGroups($userId)
  1492.     {
  1493.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1494.         $qb->add('select', 'g.groupname, g.idGroup')
  1495.             ->add('from', 'OceanExpertBundle:MemberGroups mg')
  1496.             ->leftJoin('OceanExpertBundle:Groups', 'g', 'WITH', 'mg.idGroup = g.idGroup')
  1497.             ->where('mg.idInd = :userId')
  1498.             ->setParameter('userId', $userId)
  1499.             ->orderBy('g.groupname','ASC');
  1501.         return $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1502.     }
  1504.     /**
  1505.      * get all the subject areas for a given userId
  1506.      *
  1507.      * @param int $userId the userId of the expert
  1508.      *
  1509.      * @return string
  1510.      */
  1511.     public function getSubjectAreas(int $userId): string
  1512.     {
  1513.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1514.         $qb->add('select', 's.subname,s.idSub')
  1515.             ->add('from', 'OceanExpertBundle:IndivSubjects ivs')
  1516.             ->leftJoin('OceanExpertBundle:Subjects', 's', 'WITH', 's.idSub = ivs.idSub')
  1517.             ->where('ivs.idInd = :userId')
  1518.             ->setParameter('userId', $userId);
  1520.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1521.         return implode(
  1522.             ',',
  1523.             array_column(
  1524.                 $meta,
  1525.                 'subname'
  1526.             )
  1527.         );
  1528.     }
  1530.     public function getUpdatedBy($id = '')
  1531.     {
  1532.         $updatedBy = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1533.         if ($updatedBy) {
  1534.             $name = $updatedBy->getfname() . " " . strtoupper($updatedBy->getsname());
  1535.         } else {
  1536.             $name = false;
  1537.         }
  1538.         return $name;
  1539.     }
  1541.     public function qccontrolAction(Request $request): Response
  1542.     {
  1543.         $id = $request->request->get('userId');
  1544.         $action = $request->request->get('action');
  1545.         $return = '';
  1546.         $security_context = $this->get('security.authorization_checker');
  1547.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1548.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1549.             $updatedBy = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1550.             if ($action == 1) {
  1551.                 $updatedBy->setQualityCheckedBy($author);
  1552.                 $updatedBy->setQualityCheckedDate(new DateTime('now'));
  1553.                 $updatedBy->setQualityChecked(1);
  1554.                 $return = "This record has been marked as quality controlled on <strong>" . date('F j, Y') . "</strong> by <strong>" . $this->getUpdatedBy($author)."</strong>";
  1555.             } else {
  1556.                 $updatedBy->setQualityCheckedBy(null);
  1557.                 $updatedBy->setQualityCheckedDate(null);
  1558.                 $updatedBy->setQualityChecked(0);
  1559.                 $return = "This record has not been quality controlled";
  1560.             }
  1561.             $updatedBy->setLDateUpd(new DateTime('now'));
  1562.             $updatedBy->setLastEditBy($author);
  1563.             $em = $this->getDoctrine()->getManager();
  1564.             $em->persist($updatedBy); //marks object to be saved in the next transaction.
  1565.             $em->flush(); //performs all saves and transactions.
  1566.         }
  1567.         return new Response($return);
  1568.     }
  1570.     public function setRetiredAction(Request $request): Response
  1571.     {
  1572.         $id = $request->request->get('userId');
  1573.         $date = $request->request->get('retiredDate');
  1575.         $retiredStatus = $request->request->get('retiredStatus');
  1576.         $security_context = $this->get('security.authorization_checker');
  1577.         if ($security_context->isGranted('ROLE_USER')) {
  1578.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1579.             $updateRecord = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1580.             if ($updateRecord) {
  1581.                 if ($retiredStatus == 1) {
  1582.                     $updateRecord->setRetired(1);
  1583.                     if (trim($date) == '') {
  1584.                         $updateRecord->setRetiredDate(null);
  1585.                     } else {
  1586.                         $updateRecord->setRetiredDate(DateTime::createFromFormat('Y-m-d', $date));
  1587.                     }
  1588.                 } else {
  1589.                     $updateRecord->setRetired(0);
  1590.                     $updateRecord->setRetiredDate(null);
  1591.                 }
  1592.             }
  1593.             $updateRecord->setLDateUpd(new DateTime('now'));
  1594.             $updateRecord->setLastEditBy($author);
  1595.             $em = $this->getDoctrine()->getManager();
  1596.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1597.             $em->flush(); //performs all saves and transactions.
  1598.         }
  1599.         return new Response($date);
  1600.     }
  1602.     public function setDeceasedAction(Request $request): Response
  1603.     {
  1604.         $id = $request->request->get('userId');
  1605.         $date = $request->request->get('deceasedDate');
  1606.         $deceasedStatus = $request->request->get('deceasedStatus');
  1607.         $return = '';
  1608.         $security_context = $this->get('security.authorization_checker');
  1609.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1610.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1611.             $updateRecord = $this->getDoctrine()
  1612.                 ->getRepository('OceanExpertBundle:Indiv')
  1613.                 ->findOneByIdInd($id);
  1614.             if ($updateRecord) {
  1615.                 if ($deceasedStatus == 1) {
  1616.                     $updateRecord->setDeceased(1);
  1617.                     if (trim($date) == '') {
  1618.                         $updateRecord->setDeceasedDate(null);
  1619.                     } else {
  1620.                         $updateRecord->setDeceasedDate(DateTime::createFromFormat('Y-m-d', $date));
  1621.                     }
  1622.                 } else {
  1623.                     $updateRecord->setDeceased(0);
  1624.                     $updateRecord->setDeceasedDate(null);
  1625.                 }
  1626.             }
  1627.             $updateRecord->setLDateUpd(new DateTime('now'));
  1628.             $updateRecord->setLastEditBy($author);
  1629.             $em = $this->getDoctrine()->getManager();
  1630.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1631.             $em->flush(); //performs all saves and transactions.
  1632.         }
  1633.         return new Response($return);
  1634.     }
  1636.     public function setDoNotInviteAction(Request $request): Response
  1637.     {
  1638.         $id = $request->request->get('userId');
  1639.         $status = $request->request->get('status');
  1640.         $return = '';
  1641.         $security_context = $this->get('security.authorization_checker');
  1642.         if ($security_context->isGranted('ROLE_USER')) {
  1643.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1644.             $updateRecord = $this->getDoctrine()
  1645.                 ->getRepository('OceanExpertBundle:Indiv')
  1646.                 ->findOneByIdInd($id);
  1647.             if ($updateRecord) {
  1648.                 if ($status == 1) {
  1649.                     $updateRecord->setDoNotInvite(1);
  1650.                     $updateRecord->setDoNoInviteBy($author);
  1651.                     $updateRecord->setDoNoInviteOn(new DateTime('now'));
  1652.                     $return = 'This record has been set as do not invite on <strong>' . date('F j, Y') . '</strong>';
  1653.                     $return .= 'by <strong>' . $this->getUpdatedBy($author) . '</strong>';
  1654.                 } else {
  1655.                     $updateRecord->setDoNotInvite(0);
  1656.                     $updateRecord->setDoNoInviteBy(0);
  1657.                     $updateRecord->setDoNoInviteOn(NULL);
  1658.                     $return = 'Please select "Yes" to add this member to the do not invite list.';
  1659.                 }
  1660.             }
  1661.             $updateRecord->setLDateUpd(new DateTime('now'));
  1662.             $updateRecord->setLastEditBy($author);
  1663.             $em = $this->getDoctrine()->getManager();
  1664.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1665.             $em->flush(); //performs all saves and transactions.
  1666.         }
  1667.         return new Response($return);
  1668.     }
  1670.     public function setAdmincommentsAction(Request $request): Response
  1671.     {
  1672.         $id = $request->request->get('userId');
  1673.         $comments = $request->request->get('comments');
  1674.         $return = '';
  1675.         if (trim($comments) != '') {
  1676.             $security_context = $this->get('security.authorization_checker');
  1677.             if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1678.                 $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1679.                 $updateRecord = $this->getDoctrine()
  1680.                     ->getRepository('OceanExpertBundle:Indiv')
  1681.                     ->findOneByIdInd($id);
  1682.                 $comments .= '<br />';
  1683.                 $comments .= '(Added by ' . $this->getUpdatedBy($author);
  1684.                 $comments .= ' on ' . date('d-m-y');
  1685.                 $comments .= ')<br /><br />';
  1686.                 $comments .= $updateRecord->getAdminComments();
  1687.                 if ($updateRecord) {
  1688.                     $updateRecord->setAdminComments($comments);
  1689.                 }
  1690.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1691.                 $updateRecord->setLastEditBy($author);
  1692.                 $em = $this->getDoctrine()->getManager();
  1693.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1694.                 $em->flush(); //performs all saves and transactions.
  1695.                 $return = $comments;
  1696.             }
  1697.         }
  1698.         return new Response($return);
  1699.     }
  1701.     public function setGroupsAction(Request $request): Response
  1702.     {
  1703.         $id = $request->request->get('userId');
  1704.         $groups = $request->request->get('groups');
  1705.         $return = '';
  1706.         $security_context = $this->get('security.authorization_checker');
  1707.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1708.             $author = $this->get('security.token_storage')
  1709.                 ->getToken()
  1710.                 ->getUser()
  1711.                 ->getId();
  1712.             $updateRecord = $this->getDoctrine()
  1713.                 ->getRepository('OceanExpertBundle:Indiv')
  1714.                 ->findOneByIdInd($id);
  1715.             if ($updateRecord) {
  1716.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1717.                 $updateRecord->setLastEditBy($author);
  1718.                 $em = $this->getDoctrine()->getManager();
  1719.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1720.                 $em->flush(); //performs all saves and transactions.
  1721.             }
  1722.             if (is_array($groups)) {
  1723.                 $em = $this->getDoctrine()->getManager();
  1724.                 $results = $em->createQueryBuilder()
  1725.                     ->add('select', 'm')
  1726.                     ->add('from', 'OceanExpertBundle:MemberGroups m')
  1727.                     ->where('m.idGroup not in (:groups)')
  1728.                     ->andWhere('m.idInd =:idInd')
  1729.                     ->setParameters(array('groups' => $groups, 'idInd' => $id))
  1730.                     ->getQuery()->getResult();
  1732.                 foreach ($results as $result) {
  1733.                     $em->remove($result);
  1734.                 }
  1735.                 $em->flush();
  1737.                 foreach ($groups as $value) {
  1738.                     $updateGroup = $this->getDoctrine()
  1739.                         ->getRepository('OceanExpertBundle:MemberGroups')
  1740.                         ->find(
  1741.                             array(
  1742.                                 'idInd' => $id,
  1743.                                 'idGroup' => $value
  1744.                             )
  1745.                         );
  1746.                     if (!$updateGroup) {
  1747.                         $addGroups = new MemberGroups();
  1748.                         $addGroups->setIdInd($id);
  1749.                         $addGroups->setIdGroup($value);
  1750.                         $addGroups->setRole('');
  1751.                         $addGroups->setMemberOrder(NULL);
  1752.                         $addGroups->setIsLeader(0);
  1753.                         $em = $this->getDoctrine()->getManager();
  1754.                         $em->persist($addGroups); //marks object to be saved in the next transaction.
  1755.                         $em->flush(); //performs all saves and transactions.
  1756.                     }
  1757.                 }
  1758.             } else {
  1759.                 $updateGroup = $this->getDoctrine()
  1760.                     ->getRepository('OceanExpertBundle:MemberGroups')
  1761.                     ->findBy(array('idInd' => $id));
  1762.                 $em = $this->getDoctrine()->getEntityManager();
  1763.                 foreach ($updateGroup as $groups) {
  1764.                     $em->remove($groups);
  1765.                 }
  1766.                 $em->flush();
  1767.             }
  1768.         }
  1769.         return new Response($return);
  1770.     }
  1772.     public function setPrivilegesAction(Request $request): Response
  1773.     {
  1774.         //get all the values from the request
  1775.         //these values are send from profile.html.twig $("#addPrivileges").click(function () {....
  1776.         $id = $request->request->get('userId');
  1777.         $countries = $request->request->get('countries');
  1778.         $ownInstitute = $request->request->get('ownInstitute');
  1779.         $countryList = $request->request->get('countryList');
  1780.         $editor = $request->request->get('editor');
  1783.         $security_context = $this->get('security.authorization_checker');
  1784.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1785.             $return = array(
  1786.                 'status' => 0,
  1787.                 'message' => array()
  1788.             );
  1789.             //who is doing this update
  1790.             $author = $this->get('security.token_storage')
  1791.                 ->getToken()
  1792.                 ->getUser()
  1793.                 ->getId();
  1795.             //what record needs to be updated
  1796.             $updateRecord = $this->getDoctrine()
  1797.                 ->getRepository('OceanExpertBundle:Indiv')
  1798.                 ->findOneByIdInd($id);
  1799.             if ($updateRecord) {
  1800.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1801.                 $updateRecord->setLastEditBy($author);
  1802.                 $em = $this->getDoctrine()->getManager();
  1803.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1804.                 $em->flush(); //performs all saves and transactions.
  1805.             }
  1807.             if ($ownInstitute == 1) {
  1808.                 $updateInstEdit = $this->getDoctrine()
  1809.                     ->getRepository('OceanExpertBundle:MemberEditsInstitution')
  1810.                     ->findOneBy(array(
  1811.                             'idInd' => $id,
  1812.                             'idInst' => $this->getIndivInstitute($id)
  1813.                         )
  1814.                     );
  1815.                 if (!$updateInstEdit) {
  1816.                     $updateInstEdit = new MemberEditsInstitution();
  1817.                     $updateInstEdit->setIdInd($id);
  1818.                     $updateInstEdit->setIdInst($this->getIndivInstitute($id));
  1819.                 } else {
  1820.                     $updateInstEdit->setIdInst($this->getIndivInstitute($id));
  1821.                 }
  1822.                 $em->persist($updateInstEdit); //marks object to be saved in the next transaction.
  1823.                 $em->flush(); //performs all saves and transactions.
  1824.                 $return['message'][] = 'update own institute activated';
  1825.             } else {
  1826.                 $qb = $em->createQueryBuilder();
  1827.                 $query = $qb->delete('OceanExpertBundle:MemberEditsInstitution', 'm')
  1828.                     ->where('m.idInd = :id')
  1829.                     ->andWhere('m.idInst = :idInst')
  1830.                     ->setParameters(
  1831.                         array(
  1832.                             'id' => $id,
  1833.                             'idInst' => $this->getIndivInstitute($id)
  1834.                         )
  1835.                     )
  1836.                     ->getQuery();
  1837.                 $query->execute();
  1838.                 $em->flush();
  1839.                 $return['message'][] = 'update own institute removed';
  1840.             }
  1841.             if (is_array($countries)
  1842.                 && $countryList == 1
  1843.             ) {
  1844.                 $em = $this->getDoctrine()->getManager();
  1845.                 $results = $em->createQueryBuilder()
  1846.                     ->add('select', 'm')
  1847.                     ->add('from', 'OceanExpertBundle:MemberEditsCountry m')
  1848.                     ->where('m.idCountry not in (:countries)')
  1849.                     ->andWhere('m.idInd =:idInd')
  1850.                     ->setParameters(
  1851.                         array(
  1852.                             'countries' => $countries,
  1853.                             'idInd' => $id
  1854.                         )
  1855.                     )
  1856.                     ->getQuery()->getResult();
  1858.                 foreach ($results as $result) {
  1859.                     $em->remove($result);
  1860.                 }
  1861.                 $em->flush();
  1863.                 foreach ($countries as $value) {
  1864.                     $updateCountries = $this->getDoctrine()
  1865.                         ->getRepository('OceanExpertBundle:MemberEditsCountry')
  1866.                         ->find(array(
  1867.                                 'idInd' => $id,
  1868.                                 'idCountry' => $value
  1869.                             )
  1870.                         );
  1871.                     if (!$updateCountries) {
  1872.                         $addCountry = new MemberEditsCountry();
  1873.                         $addCountry->setIdInd($id);
  1874.                         $addCountry->setIdCountry($value);
  1875.                         $em = $this->getDoctrine()->getManager();
  1876.                         $em->persist($addCountry); //marks object to be saved in the next transaction.
  1877.                         $em->flush(); //performs all saves and transactions.
  1878.                     }
  1879.                 }
  1880.                 $return['message'][] = 'countries added';
  1881.             } else {
  1882.                 $updateGroup = $this->getDoctrine()
  1883.                     ->getRepository('OceanExpertBundle:MemberEditsCountry')
  1884.                     ->findBy(array('idInd' => $id));
  1885.                 $em = $this->getDoctrine()->getEntityManager();
  1886.                 foreach ($updateGroup as $groups) {
  1887.                     $em->remove($groups);
  1888.                 }
  1889.                 $em->flush();
  1890.                 $return['message'][] = 'countries removed';
  1891.             }
  1894.             $user= $em->getRepository('OceanExpertBundle:User')
  1895.                 ->findOneBy(
  1896.                     array(
  1897.                         'id' => $id
  1898.                     )
  1899.                 );
  1900.             if($editor == 1) {
  1901.                 $user->addRole("ROLE_GLOBAL_EDITOR");
  1902.                 $return['message'][] = 'global editor activated';
  1903.             } elseif ($editor == 0) {
  1904.                 $user->removeRole('ROLE_GLOBAL_EDITOR');
  1905.                 $return['message'][] = 'global editor removed';
  1906.             }
  1907.             $em->persist($user);
  1908.             $em->flush();
  1910.         } else {
  1911.             $return = array(
  1912.                 'status' => 1,
  1913.                 'error' => 'you have no rights to do this'
  1914.             );
  1915.         }
  1916.         return new Response(json_encode($return));
  1917.     }
  1919.     public function resetPasswordLinkAction(Request $request): Response
  1920.     {
  1921.         if ($request->query->get('username')) {
  1922.             $username = $request->query->get('username');
  1923.         } else {
  1924.             $username = $request->request->get('username');
  1925.         }
  1927.         $user = $this->fosUserManager->findUserByUsernameOrEmail($username);
  1929.         if (null === $user) {
  1930.             $return = "Error in sending email. User not found.";
  1931.             return new Response($return);
  1932.         }
  1934.         if (null === $user->getConfirmationToken()) {
  1935.             $user->setConfirmationToken($this->fosTokenGenerator->generateToken());
  1936.         }
  1938.         $this->fosMailer->sendResettingEmailMessage($user);
  1939.         $user->setPasswordRequestedAt(new DateTime());
  1940.         $this->fosUserManager->updateUser($user);
  1941.         $return = "Password reset link send successfully.";
  1942.         if ($request->query->get('username')) {
  1943.             $email = $user->getEmail();
  1944.             if (false !== $pos = strpos($email, '@')) {
  1945.                 $email = '...' . substr($email, $pos);
  1946.             }
  1947.             return new RedirectResponse(
  1948.                 $this->generateUrl(
  1949.                     'fos_user_resetting_check_email',
  1950.                     array('email' => $email)
  1951.                 )
  1952.             );
  1953.         }
  1955.         return new Response($return);
  1956.     }
  1958.     public function getIndivInstitute($idInd)
  1959.     {
  1960.         $getInstId = $this->getDoctrine()
  1961.             ->getRepository('OceanExpertBundle:IndivInstitution')
  1962.             ->findOneByIdInd($idInd);
  1963.         if ($getInstId) {
  1964.             return $getInstId->getIdInst();
  1965.         } else {
  1966.             return 0;
  1967.         }
  1968.     }
  1970.     /**
  1971.      * @return Response
  1972.      */
  1973.     public function assignRolesAction(Request $request): Response
  1974.     {
  1975.         $username =  $request->request->get('username');
  1977.         $allAssignedRoles = array();
  1978.         $allRevokedRoles = array();
  1980.         $em = $this->getDoctrine()->getManager();
  1981.         $user= $em->getRepository("OceanExpertBundle:User")
  1982.             ->findOneBy(
  1983.                 array(
  1984.                     'username' => $username
  1985.                 )
  1986.             );
  1988.         if ($request->request->get('superadmin')==1) {
  1989.             $user->addRole('ROLE_SUPERADMIN');
  1990.             $allAssignedRoles[] = 'ROLE_SUPERADMIN';
  1991.         } else {
  1992.             $user->removeRole('ROLE_SUPERADMIN');
  1993.             $allRevokedRoles[] = 'ROLE_SUPERADMIN';
  1994.         }
  1995.         if ($request->request->get('oceancdadmin')==1) {
  1996.             $user->addRole('ROLE_OCEANCD');
  1997.             $allAssignedRoles[] = 'ROLE_OCEANCD';
  1998.         } else {
  1999.             $user->removeRole('ROLE_OCEANCD');
  2000.             $allRevokedRoles[] = 'ROLE_OCEANCD';
  2001.         }
  2002.         if ($request->request->get('odiscatadmin')==1) {
  2003.             $user->addRole('ROLE_ODISCATADMIN');
  2004.             $allAssignedRoles[] = 'ROLE_ODISCATADMIN';
  2005.         } else {
  2006.             $user->removeRole('ROLE_ODISCATADMIN');
  2007.             $allRevokedRoles[] = 'ROLE_ODISCATADMIN';
  2008.         }
  2009.         if ($request->request->get('administrator')==1) {
  2010.             $user->addRole('ROLE_ADMIN');
  2011.             $allAssignedRoles[] = 'ROLE_ADMIN';
  2012.         } else {
  2013.             $user->removeRole('ROLE_ADMIN');
  2014.             $allRevokedRoles[] = 'ROLE_ADMIN';
  2015.         }
  2016.         if ($request->request->get('manager')==1) {
  2017.             $user->addRole('ROLE_MANAGER');
  2018.             $allAssignedRoles[] = 'ROLE_MANAGER';
  2019.         } else {
  2020.             $user->removeRole('ROLE_MANAGER');
  2021.             $allRevokedRoles[] = 'ROLE_MANAGER';
  2022.         }
  2023.         if ($request->request->get('lme')==1) {
  2024.             $user->addRole('ROLE_LME');
  2025.             $allAssignedRoles[] = 'ROLE_LME';
  2026.         } else {
  2027.             $user->removeRole('ROLE_LME');
  2028.             $allRevokedRoles[] = 'ROLE_LME';
  2029.         }
  2030.         $em->persist($user);
  2031.         $em->flush();
  2033.         return new JsonResponse(
  2034.             array(
  2035.                 'status' => 1 ,
  2036.                 'message' => 'Role(s) assigned successfully',
  2037.                 'username' => $username,
  2038.                 'assigned' => implode(',', $allAssignedRoles),
  2039.                 'revoked' => implode(', ', $allRevokedRoles),
  2040.                 'user' => $user
  2041.             )
  2042.         );
  2043.     }
  2045.     /**
  2046.      * @return JsonResponse
  2047.      */
  2048.     public function getExpertsAjaxAction(Request $request): Response
  2049.     {
  2050.         if (!null == $request->query->get('q')) {
  2051.             $query = $request->query->get('q');
  2052.             $em = $this->getDoctrine()->getManager();
  2053.             $connection = $em->getConnection();
  2054.             $statement = $connection->prepare("SELECT 
  2055.                 i.id_ind AS id, 
  2056.                 i.fname, 
  2057.                 i.sname, 
  2058.                 i.jobtitle,
  2059.                 inst.inst_name,
  2060.                 c.country 
  2061.             FROM indiv i
  2062.             LEFT JOIN countries c ON c.id_country =  i.country_code
  2063.             LEFT JOIN indiv_institution ii ON ii.id_ind = i.id_ind
  2064.             LEFT JOIN institutions inst ON inst.id_inst = ii.id_inst
  2065.             LEFT JOIN countries ic ON ic.id_country =  inst.country_code
  2066.             WHERE ( MATCH (fname,sname) AGAINST (:searchterm IN BOOLEAN MODE) 
  2067.                 OR fname like '%$query%' 
  2068.                 OR fname like '%$query%' 
  2069.                 OR sname like '%$query%' 
  2070.                 OR sname like '%$query%') 
  2071.                 AND status = 1;
  2072.             ");
  2073.             $statement->bindValue('searchterm', $query);
  2074.             $statement->execute();
  2075.             $query = $statement->fetchAll();
  2077.             $data = array();
  2078.             if($query) {
  2079.                 $data = array(
  2080.                     'incomplete_results' => false,
  2081.                     'items' => $query,
  2082.                     'total_count' => count($query),
  2083.                 );
  2084.             }
  2086.             return new JsonResponse($data);
  2087.         }
  2088.         return new JsonResponse(array());
  2089.     }
  2091.     /**
  2092.      * @param int     $idInd
  2093.      * @param Request $request
  2094.      *
  2095.      * @return mixed
  2096.      */
  2097.     function getExpertEventParticipation(int $idInd, Request $request) {
  2098.         $em = $this->getDoctrine()->getManager();
  2099.         $participation = $em->createQueryBuilder()
  2100.             ->add('select', 'ep.idEvent')
  2101.             ->add('from', 'OceanExpertBundle:EventParticipants ep')
  2102.             ->where('ep.idInd =:idInd')
  2103.             ->setParameters(array('idInd' => $idInd ))
  2104.             ->getQuery()->getResult();
  2105.         $participation = array_column($participation, "idEvent");
  2106.         $contacts = $em->createQueryBuilder()
  2107.             ->add('select', 'ec.idEvent')
  2108.             ->add('from', 'OceanExpertBundle:EventContacts ec')
  2109.             ->where('ec.idInd =:idInd')
  2110.             ->setParameters(array('idInd' => $idInd ))
  2111.             ->getQuery()->getResult();
  2112.         $contacts = array_column($contacts, "idEvent");
  2113.         $staff = $em->createQueryBuilder()
  2114.             ->add('select', 'es.idEvent')
  2115.             ->add('from', 'OceanExpertBundle:EventStaff es')
  2116.             ->where('es.idInd =:idInd')
  2117.             ->setParameters(array('idInd' => $idInd ))
  2118.             ->getQuery()->getResult();
  2119.         $staff = array_column($staff, "idEvent");
  2120.         $results = array_merge($participation,$contacts,$staff);
  2121.         $results = array_unique($results);
  2123.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  2124.         $qb->add('select', 'e.idEvent, e.title, e.idEventtype, e.startOn, e.endOn, e.address, e.city, e.state, e.postcode, c.country')
  2125.             ->add('from', 'OceanExpertBundle:Events e')
  2126.             ->leftJoin('OceanExpertBundle:Countries', 'c', 'WITH', 'e.idCountry = c.idCountry')
  2127.             ->where('e.idEvent in (:idEvent)')
  2128.             ->andWhere('e.status = 1')
  2129.             ->orderBy('e.startOn', 'DESC')
  2130.             ->setParameter('idEvent', $results );
  2131.         $resultData = $qb->getQuery()->getResult();
  2133.         $paginator = $this->get('knp_paginator');
  2134.         $members = $paginator->paginate(
  2135.             $resultData,
  2136.             $request->query->getInt('page', 1),
  2137.             5,
  2138.             array(
  2139.                 'pageParameterName' => 'page',
  2140.                 'sortDirectionParameterName' => 'dir'
  2141.             )
  2142.         );
  2144.         //@todo some code goes here (i.e. your symfony request dispatching)
  2146.         return $members;
  2147.     }
  2148. }