src/OceanExpertBundle/Controller/ProfileController.php line 2089

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.             if (isset($expertAddressInfo['countryCode'])
  311.                 && $expertAddressInfo['countryCode'] != ''
  312.             ) {
  313.                 $OIHCountries = $this->getCountryFromIds(
  314.                         explode(
  315.                             ',',
  316.                             $expertAddressInfo['countryCode']
  317.                         )
  318.                     );
  319.                 //we can only gave one country for the workinglocation
  320.                 $OIHAddress .= ', ' . $OIHCountries[0]['country'];
  321.                 $OIHLatitude = $OIHCountries[0]['latitude'];
  322.                 $OIHLongitude = $OIHCountries[0]['longitude'];
  324.             }
  325.             $OIHData['workLocation'] = array(
  326.                 '@type' => 'Place',
  327.                 'address' => trim($OIHAddress),
  328.                 'geo' => array(
  329.                     '@type' => 'GeoCoordinates',
  330.                     "latitude" => $OIHLatitude,
  331.                     "longitude" => $OIHLongitude
  332.                 )
  333.             );
  336.             /*
  337.                 "geo": {
  338.                     "@type": "GeoCoordinates",
  339.                     "latitude": 39.3280,
  340.                     "longitude": 120.1633
  341.                 }
  342.             */
  344.             //get the languages for OIH
  345.             //we expect
  346.             /*
  347.             "knowsLanguage": {
  348.                 "@type": "Language",
  349.                 "name": "Spanish",
  350.                 "alternateName": "es"
  352.             }
  353.             */
  354.             $allLanguages = $this->getDoctrine()
  355.                 ->getRepository('OceanExpertBundle:Languages')
  356.                 ->findAll();
  357.             //dump($allLanguages);
  358.             if (isset($expert['expertInfo']['languages'])) {
  359.                 $knowsLanguages = explode(',', $expert['expertInfo']['languages']);
  360.                 foreach ($knowsLanguages as $knowsLanguage) {
  361.                     $OIHData['knowsLanguage'][] = array(
  362.                         '@type' => 'Language',
  363.                         'name' => trim($knowsLanguage)
  364.                     );
  365.                 }
  366.             }
  368.             if (isset($expert['expertInfo']['jobtitle'])) {
  369.                 $expert['jobtitle'] = $this->getJobTypeByCodes(
  370.                     explode(
  371.                         ',',
  372.                         $expert['expertInfo']['jobtitle'])
  373.                 );
  375.                 $OIHData['jobTitle'] = trim($expert['expertInfo']['jobtitle']);
  376.             }
  378.             if (isset($expert['0']['lastEditBy'])) {
  379.                 $expert['lastEditBy'] = $this->getUpdatedBy($expert['0']['lastEditBy']);
  380.             }
  382.             if (isset($expert['0']['createdBy'])) {
  383.                 $expert['createdBy'] = $this->getUpdatedBy($expert['0']['createdBy']);
  384.             }
  386.             $expert['subjectArea'] = $this->getSubjectAreas($idInd);
  387.             if ($expert['subjectArea']
  388.                 && $expert['subjectArea'] != ''
  389.             ) {
  390.                 $subjectAreas = explode(',', $expert['subjectArea']);
  391.                 foreach ($subjectAreas as $subjectArea) {
  392.                     $OIHData['knowsAbout'][] = trim($subjectArea);
  393.                 }
  394.             }
  396.             /*
  397.              * nationality
  398.              * we expect something like
  399.              * "nationality": {
  400.                 "@type": "Country",
  401.                 "name": "Fiji",
  402.                 "identifier": {
  403.                     "@type": "PropertyValue",
  404.                     "name": "ISO 3166-1 alpha-2 code",
  405.                     "value": "FJ",
  406.                     "propertyID": [
  407.                         "https://unece.org/trade/cefact/unlocode-code-list-country-and-territory",
  408.                         "ISO 3166-1:2020"
  409.                     ]
  410.                 }
  411.         },
  412.              */
  413.             if (isset($expert['expertInfo']['idNationality'])) {
  414.                 $nationalities = $this->getCountryFromIds(
  415.                     explode(
  416.                         ',',
  417.                         $expert['expertInfo']['idNationality']
  418.                     )
  419.                 );
  421.                 foreach($nationalities as $OIHNationality) {
  422.                     $expert['nationality'][]  = trim($OIHNationality['country']);
  423.                     $OIHData['nationality'][] = array(
  424.                         '@type' => 'Country',
  425.                         'name' => trim($OIHNationality['country'])
  426.                     );
  427.                     /*
  428.                      * #808
  429.                      *
  430.                     $OIHData['nationality'][] = array(
  431.                         '@type' => 'DefinedTerm',
  432.                         'url' => 'https://unece.org/trade/cefact/unlocode-code-list-country-and-territory',
  433.                         'inDefinedTermSet' => 'UN/LOCODE Code List by Country and Territory',
  434.                         'name' => trim($OIHNationality['country']),
  435.                         'termCode' =>trim($OIHNationality['countryCode'])
  436.                     );
  437.                     */
  438.                 }
  439.                 if (isset($expert['nationality'])
  440.                     && is_array($expert['nationality'])
  441.                 ) {
  442.                     $expert['nationality'] = implode(
  443.                         ',',
  444.                         $expert['nationality']
  445.                     );
  446.                 }
  447.             }
  449.             foreach (array('url1', 'url2', 'url3') as $urlId) {
  450.                 if (isset($expert['expertInfo'][$urlId])
  451.                     && trim($expert['expertInfo'][$urlId]) != ''
  452.                 ) {
  453.                     $OIHData['url'][] = trim($expert['expertInfo'][$urlId]);
  454.                 }
  455.             }
  457.             if (isset($expert['expertInfo']['studyregion'])) {
  458.                 $expert['studyregion'] = $this->getResearchAreaByCodes(
  459.                     explode(
  460.                         ',',
  461.                         $expert['expertInfo']['studyregion']
  462.                     )
  463.                 );
  464.             }
  467.             if (isset($expert['expertInfo']['qualityCheckedBy'])) {
  468.                 $expert['qcby'] = $this->getUpdatedBy($expert['expertInfo']['qualityCheckedBy']);
  469.             }
  471.             if (isset($expert['expertInfo']['doNoInviteBy'])
  472.                 && isset($expert['expertInfo']['doNoInviteBy']) != 0
  473.             ) {
  474.                 $expert['doNoInviteBy'] = $this->getUpdatedBy($expert['expertInfo']['doNoInviteBy']);
  475.             }
  477.             if (isset($expert['expertInfo']['twitter'])) {
  478.                 $twitterUser = $expert['expertInfo']['twitter'];
  479.                 if (preg_match('/(@.+)/', $twitterUser, $matches)) {
  480.                     $twitterUser = 'https://twitter.com/' . $matches[1];
  481.                 }
  482.                 $expert['twitter'] = $twitterUser;
  483.             }
  485.             //$em->getManager()->getRepository('OceanExpertBundle:MemberGroups');
  486.             $query = $em->getManager()
  487.                 ->createQueryBuilder('m')
  488.                 ->select('m.idGroup')
  489.                 ->add('from','OceanExpertBundle:MemberGroups m')
  490.                 ->where('m.idInd =:idInd')
  491.                 ->setParameter('idInd', $idInd)
  492.                 ->getQuery();
  493.             $groups = $query->getResult();
  494.             $expert['groupids'] = array_column($groups, 'idGroup');
  495.             //$em->getRepository('OceanExpertBundle:MemberEditsCountry');
  496.             $query = $em->getManager()
  497.                 ->createQueryBuilder('m')
  498.                 ->select('m.idCountry')
  499.                 ->add('from','OceanExpertBundle:MemberEditsCountry m')
  500.                 ->where('m.idInd =:idInd')
  501.                 ->setParameter('idInd', $idInd)
  502.                 ->getQuery();
  503.             $countries = $query->getResult();
  504.             $expert['countries'] = array_column($countries, 'idCountry');
  505.             //$em->getRepository('OceanExpertBundle:MemberEditsInstitution');
  506.             $expert['canEditOwnInst'] = 0;
  507.             if (isset($expert['idInst'])) {
  508.                 $query = $em->getManager()
  509.                     ->createQueryBuilder('m')
  510.                     ->select('m')
  511.                     ->add('from','OceanExpertBundle:MemberEditsInstitution m')
  512.                     ->where('m.idInd =:idInd')
  513.                     ->andWhere('m.idInst =:idInst')
  514.                     ->setParameters(
  515.                         array(
  516.                             'idInst' => $expert['idInst'],
  517.                             'idInd' => $idInd
  518.                         )
  519.                     )
  520.                     ->getQuery();
  521.                 $canEditOwnInst = $query->getOneOrNullResult(AbstractQuery::HYDRATE_ARRAY);
  522.                 if (is_array($canEditOwnInst)
  523.                     && count($canEditOwnInst)
  524.                 ) {
  525.                     $expert['canEditOwnInst'] = 1;
  526.                 }
  527.             }
  529.             $fosUserData = $this->fosUserManager
  530.                 ->findUserBy(
  531.                     array(
  532.                         'id' => $idInd
  533.                     )
  534.                 );
  536.             if ($fosUserData) {
  537.                 $expert['roles'] = $fosUserData->getRoles();
  538.                 $expert['username'] = $fosUserData->getUsername();
  539.                 $expert['id'] = $fosUserData->getId();
  540.                 $expert['email'] = $fosUserData->getEmail();
  541.                 $userLink = $this->generateUrl(
  542.                     'view_profile',
  543.                     array(
  544.                         'user' => $expert['id']
  545.                     )
  546.                 );
  547.                 $expert['profileUrl'] = $request->getUriForPath($userLink);
  548.             }
  550.             $adminOption['countries'] = $this->getDoctrine()
  551.                 ->getRepository('OceanExpertBundle:Countries')
  552.                 ->findBy(
  553.                     [],
  554.                     ['country' => 'ASC']
  555.                 );
  557.             if (isset($expert[1]['path'])) {
  558.                 $expert['imgPath'] = $request
  559.                     ->getUriForPath('/uploads/profile/' . $expert[1]['path']);
  560.             }
  562.             $adminOption['userGroups'] = $this->getDoctrine()
  563.                 ->getRepository('OceanExpertBundle:Groups')
  564.                 ->findBy(
  565.                     [],
  566.                     ['groupname' => 'ASC']
  567.                 );
  570.             /*
  571.              * #552
  572.              * overruled by #808 and the new pattern definition
  573.              *
  574.              * we want something like this
  575.              * {
  576.                   "@id": "https://example.org/id/course/x",
  577.                   "@type": "Course",
  578.                   "description": "In this course ...",
  579.                   "url": "URL to the course"
  580.                 }
  581.              */
  582.             $OIHEventData = $this->getExpertEventParticipation(
  583.                 $idInd,
  584.                 $request
  585.             );
  587.             if ($this->container->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  588.                 $eventData =$OIHEventData;
  589.             }
  591.             foreach ($OIHEventData as $event) {
  592.                 //we only want to see the courses, not all meetings!!!!
  593.                 if ($event['idEventtype'] == 4) {
  594.                     $OIHData['knowsAbout'][] = array(
  595.                         '@id' => 'https://www.oceanexpert.org/event/' . $event['identifier'],
  596.                         '@type' => 'Course',
  597.                         'description' => $event['description'],
  598.                         'url' => 'https://www.oceanexpert.org/event/' . $event['identifier'],
  599.                         'endDate' => $event['endDate'],
  600.                         'startDate' => $event['startDate']
  601.                     );
  602.                 }
  603.             }
  605.             if (isset($metadata['orcid'])
  606.                 && $metadata['orcid'] != ''
  607.             ) {
  608.                 $OIHData['identifier'][] = array(
  609.                     '@id' => $metadata['orcid'],
  610.                     '@type' => 'PropertyValue',
  611.                     'propertyID' => 'https://registry.identifiers.org/registry/orcid',
  612.                     'url' => 'https://orcid.org/' . $metadata['orcid']
  613.                 );
  614.             }
  616.             if (isset($metadata['researcherid'])
  617.                 && $metadata['researcherid'] != ''
  618.             ) {
  619.                 $OIHData['identifier'][] = array(
  620.                     '@id' => $metadata['researcherid'],
  621.                     '@type' => 'PropertyValue',
  622.                     'propertyID' => 'https://www.researcherid.com',
  623.                     'url' => 'https://www.researcherid.com/' . $metadata['researcherid']
  624.                 );
  625.             }
  627.             if (isset($metadata['researcharea'])
  628.                 && $metadata['researcharea'] != ''
  629.             ) {
  630.                 $researchArea = str_replace('\r', ', ' , $metadata['researcharea']);
  631.                 $researchArea = str_replace('  ', ' ' , $researchArea);
  632.                 $OIHData['knowsAbout'][] = $researchArea;
  633.             }
  634.         }  else {
  635.             //we did not find user info
  636.             //this can be a new profile
  637.             //check if we can find login credentials
  638.             $searchUser = $this->fosUserManager
  639.                 ->findUserBy(
  640.                     array(
  641.                         'id' => $idInd
  642.                     )
  643.                 );
  645.             //we found credentials
  646.             //only show info for global editors or for the user himself
  647.             //else the profile data can never be completed
  648.             if (!null == $searchUser
  649.                 && ($this->get('security.authorization_checker')->isGranted('ROLE_GLOBAL_EDITOR'))
  650.                 || ($isLoggedIn
  651.                     && ($idInd == $loggedUser->getId())
  652.                 )
  653.             ) {
  654.                 $expert['expertInfo']['idInd'] = $idInd;
  655.                 $expert['username'] = $searchUser->getUsername();
  656.                 $expert['error'] = 'Incomplete Profile.';
  657.             } else {
  658.                 $expert = array(
  659.                     'error' => 'User not found.'
  660.                 );
  661.             }
  662.         }
  664.         $OIHData = json_encode(
  665.             $OIHData,
  666.             JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK
  667.         );
  669.         //dump($expert);
  670.         return $this->render(
  671.             'Profile/profile.html.twig',
  672.             array(
  673.                 'OIHData' => $OIHData,
  674.                 'expert' => $expert,
  675.                 'metadata' => $metadata,
  676.                 'adminOption' => $adminOption,
  677.                 'eventData' => $eventData
  678.             )
  679.         );
  680.     }
  682.     /**
  683.      * get the data of an expert to show on the profile page
  684.      *
  685.      * @param Request $request
  686.      *
  687.      * @return Response
  688.      *
  689.      * @throws ContainerExceptionInterface
  690.      * @throws NotFoundExceptionInterface
  691.      *
  692.      * @todo fix missing $data
  693.      *
  694.      */
  695.     public function userProfileAction(Request $request): Response
  696.     {
  697.         $data = $request->request->all();
  699.         $username = '';
  700.         if ($this->container->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_FULLY')) {
  701.             $username = $this->get('security.token_storage')->getToken()->getUser()->getUsername();
  702.         }
  704.         if (!isset($data['userEmail'])) {
  705.             if ($username !== '') {
  706.                 return $this->redirect('expert/' . $username);
  707.             } else {
  708.                 //no such user, strange...
  709.                 $message = "Cannot find user without email address and without username.";
  710.                 return $this->render(
  711.                     'Default/error.html.twig',
  712.                     array(
  713.                         'message' => $message
  714.                     )
  715.                 );
  716.             }
  717.         }
  719.         //this should have been checked before
  720.         //but better be safe than sorry
  721.         $data['userEmail'] = filter_var(
  722.             $data['userEmail'],
  723.             FILTER_SANITIZE_EMAIL
  724.         );
  726.         $userId = $this->fosUserManager->findUserByEmail($data['userEmail'])->getId();
  727.         unset($data['_wysihtml5_mode']);
  728.         $data = array_filter($data);
  729.         if (isset($data['researcharea'])) {
  730.             $data['research'] = $this->getResearchAreaByCodes($data['researcharea']);
  731.         }
  732.         if (isset($data['studyregion'])) {
  733.             $data['study'] = $this->getResearchAreaByCodes($data['studyregion']);
  734.         } else {
  735.             $data['studyregion'] = array();
  736.         }
  738.         if (null !== ($data['country'])) {
  739.             $data['countryName'] = $this->getCountryByCode($data['country']);
  740.         }
  741.         if (null !== ($data['jobtype'])) {
  742.             $data['job'] = $this->getJobTypeByCodes($data['jobtype']);
  743.         }
  744.         if ($data['regType'] == '1') {
  745.             $data['type'] = "Organization";
  746.         } else {
  747.             $data['type'] = "Personal";
  748.             $data['country'] = $data['country2'];
  749.             $data['locality'] = isset($data['city2']) ? $data['city2'] : '';
  750.             $data['administrative_area_level_1'] = isset($data['state2']) ? $data['state2'] : '';
  751.             $data['postal_code'] = isset($data['postcode2']) ? $data['postcode2'] : '';
  752.             $data['box'] = isset($data['box2']) ?: '';
  753.             $data['route'] = isset($data['address2']) ? $data['address2'] : '';
  754.             $data['addrline2'] = isset($data['addrline2']) ? $data['addrline2'] : '';
  756.         }
  757.         if (null !== $request->files->get('file')) {
  758.             $file = $request->files->get('file');
  759.             $filetype = $request->files->get('file')->guessClientExtension();
  760.             $filename = "profile_" . $userId . "." . $filetype;
  761.             $em = $this->getDoctrine()->getManager();
  762.             $item = $em->getRepository('OceanExpertBundle:ProfileImages')->findOneBy(array('idInd' => $userId));
  763.             if ($item) {
  764.                 $item->setFile($file);
  765.                 $item->setName($filename);
  766.                 $item->setPath($filename);
  767.                 $item->upload();
  768.                 $em->persist($item);
  769.                 $em->flush();
  770.                 $data['profileId'] = $item->getId();
  771.             } else {
  772.                 $profile = new ProfileImages();
  773.                 $profile->setFile($file);
  774.                 $profile->setName($filename);
  775.                 $profile->setPath($filename);
  776.                 $profile->setIdInd($userId);
  777.                 $profile->upload();
  778.                 $em->persist($profile);
  779.                 $em->flush();
  780.                 if ($profile) {
  781.                     $data['profileId'] = $profile->getId();
  782.                 }
  783.             }
  784.         }
  786.         try {
  788.             /*
  789.              * this is incorrect
  790.              * see also#659
  791.              *
  792.             $privateaddress = isset($data['route'])?trim($data['route']) . '<br />':'';
  793.             $privateaddress .= isset($data['addrline2'])?trim($data['addrline2']) . '<br />':'';
  794.             $privateaddress .= isset($data['postal_code'])?trim($data['postal_code']).", ":'';
  795.             $privateaddress .= isset($data['locality'])?trim($data['locality']).", ":'';
  796.             $privateaddress .= isset($data['administrative_area_level_1'])?trim($data['administrative_area_level_1']) . '<br />':'';
  797.             $privateaddress .= isset($data['country'])?trim($this->getCountryByCode($data['country'])) . '<br />':'';
  798.             */
  800.             $indiv = new Indiv();
  801.             $indiv->setTitle(isset($data['title']) ? $data['title'] : '');
  802.             $indiv->setFname(isset($data['firstname']) ? $data['firstname'] : '');
  803.             $indiv->setMname(isset($data['middlename']) ? $data['middlename'] : '');
  804.             $indiv->setSname(isset($data['lastname']) ? $data['lastname'] : '');
  805.             $indiv->setRegType(isset($data['reg-type']) ? $data['reg-type'] : '');
  806.             $indiv->setIdentifier('');
  807.             $indiv->setUseInstAddr(isset($data['useinstaddress']) ? $data['useinstaddress'] : 0);
  808.             /*
  809.              * this is incorrect
  810.              * see also#659
  811.              */
  812.             $indiv->setPrivateAddress('');
  813.             $indiv->setCity(isset($data['locality']) ? $data['locality'] : '');
  814.             $indiv->setAddr1(isset($data['route']) ? $data['route'] : '');
  815.             $indiv->setAddr2(isset($data['addrline2']) ? $data['addrline2'] : '');
  816.             $indiv->setState(isset($data['administrative_area_level_1']) ? $data['administrative_area_level_1'] : '');
  817.             $indiv->setPostcode(isset($data['postal_code']) ? $data['postal_code'] : '');
  818.             $indiv->setCountryCode(isset($data['country']) ? $data['country'] : '');
  819.             $indiv->setIDNationality(isset($data['id_nationality']) ? $data['id_nationality'] : 0);
  820.             $indiv->setGender(isset($data['gender']) ? $data['gender'] : '');
  821.             $indiv->setTel(isset($data['phone']) ? $data['phone'] : '');
  823.             //we are already in a condition where we are sure the $data['userEmail'] exists
  824.             //and is well-formed
  825.             $indiv->setEmail1($data['userEmail']);
  827.             if (isset($data['alternateEmail'])
  828.                 && $data['alternateEmail'] !== ''
  829.                 && filter_var($data['alternateEmail'], FILTER_VALIDATE_EMAIL)
  830.             ) {
  831.                 $data['alternateEmail'] = filter_var(
  832.                     $data['alternateEmail'],
  833.                     FILTER_SANITIZE_EMAIL
  834.                 );
  835.             } else {
  836.                 $data['alternateEmail'] = '';
  837.             }
  838.             $indiv->setEmail2($data['alternateEmail']);
  839.             $indiv->setEmail3(isset($data['']) ? $data[''] : '');
  840.             $indiv->setUrl1(isset($data['website-personal']) ? $data['website-personal'] : '');
  841.             $indiv->setUrl2(isset($data['website-institution']) ? $data['website-institution'] : '');
  842.             $indiv->setLinkedin(isset($data['linkedin']) ? $data['linkedin'] : '');
  843.             $indiv->setFacebook(isset($data['facebook']) ? $data['facebook'] : '');
  844.             $indiv->setTwitter(isset($data['twitter']) ? $data['twitter'] : '');
  845.             $indiv->setOther(isset($data['other']) ? $data['other'] : '');
  846.             $indiv->setDegree(isset($data['degree']) ? $data['degree'] : '');
  847.             $indiv->setJobtitle(isset($data['job']) ? $data['job'] : '');
  848.             $indiv->setDept(isset($data['department']) ? $data['department'] : '');
  849.             $indiv->setStudyregion(isset($data['study']) ? $data['study'] : '');
  850.             $indiv->setLanguages(implode(',', $data['languages']));
  851.             $indiv->setComments(isset($data['comments']) ? $data['comments'] : '');
  852.             $indiv->setSkills(isset($data['skills']) ? $data['skills'] : '');
  853.             $indiv->setIdImagefile(isset($data['profileId']) ? $data['profileId'] : null);
  854.             $indiv->setFDateEnt(new DateTime('now'));
  855.             $indiv->setLDateUpd(new DateTime('now'));
  856.             $indiv->setCreatedBy(isset($data['']) ? $data[''] : 0);
  857.             $indiv->setLastEditBy(isset($data['']) ? $data[''] : 0);
  858.             $indiv->setFax(isset($data['']) ? $data[''] : '');
  859.             $indiv->setUrl3(isset($data['']) ? $data[''] : '');
  860.             $indiv->setUrlsChecked(new DateTime('now'));
  861.             $indiv->setFlickr(isset($data['']) ? $data[''] : '');
  862.             $indiv->setActiveng(isset($data['']) ? $data[''] : '');
  863.             $indiv->setActivother(isset($data['']) ? $data[''] : '');
  864.             $indiv->setDoNotInvite(isset($data['']) ? $data[''] : 0);
  865.             $indiv->setAdminComments(isset($data['']) ? $data[''] : '');
  866.             $indiv->setIsGlobal(isset($data['']) ? $data[''] : 0);
  867.             $indiv->setStatus(isset($data['']) ? $data[''] : 0);
  868.             $indiv->setStatusLastChanged(new DateTime());
  869.             $indiv->setDeceased(isset($data['']) ? $data[''] : 0);
  870.             $indiv->setRetired(isset($data['']) ? $data[''] : 0);
  872.             $em = $this->getDoctrine()->getManager();
  873.             $em->persist($indiv); //marks object to be saved in the next transaction.
  874.             $em->flush(); //performs all saves and transactions.
  875.             if (!isset($data['orcid'])) {
  876.                 $data['orcid'] = '';
  877.             }
  878.             if (!isset($data['researcherid'])) {
  879.                 $data['researcherid'] = '';
  880.             }
  881.             if (!isset($data['google-scholar'])) {
  882.                 $data['google-scholar'] = '';
  883.             }
  884.             if (!isset($data['researchgate'])) {
  885.                 $data['researchgate'] = '';
  886.             }
  887.             if (!isset($data['others'])) {
  888.                 $data['others'] = '';
  889.             }
  890.             if (!isset($data['researcharea'])) {
  891.                 $data['researcharea'] = array();
  892.             }
  894.             if ($indiv->getIdInd()) {
  895.                 $usermeta = array(
  896.                     'orcid' => $data['orcid'],
  897.                     'researcherid' => $data['researcherid'],
  898.                     'researcharea' => implode(', ', $data['researcharea']),
  899.                     'google-scholar' => $data['google-scholar'],
  900.                     'researchgate' => $data['researchgate'],
  901.                     'others' => $data['others']
  902.                 );
  903.                 $usermeta = array_filter($usermeta);
  905.                 foreach ($usermeta as $key => $value) {
  906.                     $chkmeta = $em->getRepository('OceanExpertBundle:IndivMeta')
  907.                         ->findOneBy(
  908.                             array(
  909.                                 'indivId' => $indiv->getIdInd(),
  910.                                 'metaOption' => $key
  911.                             )
  912.                         );
  914.                     if ($chkmeta) {
  915.                         $chkmeta->setMetaValue($value);
  916.                         $em->persist($chkmeta);
  917.                         $em->flush();
  918.                     } else {
  919.                         $meta = new IndivMeta();
  920.                         $meta->setIndivId($indiv->getIdInd());
  921.                         $meta->setMetaOption($key);
  922.                         $meta->setMetaValue($value);
  923.                         $em = $this->getDoctrine()->getManager();
  924.                         $em->persist($meta);
  925.                         $em->flush();
  926.                     }
  927.                 }
  928.             }
  929.         } catch (Exception $e) {
  930.             //return error message
  931.             $message = $e->getMessage();
  932.             return $this->render(
  933.                 'Default/error.html.twig',
  934.                 array(
  935.                     'message' => $message
  936.                 )
  937.             );
  938.         }
  940.         return $this->redirect(
  941.             $this->generateUrl(
  942.                 'profile_status'
  943.             )
  944.         );
  945.     }
  947.     /**
  948.      * edit an existing user profile
  949.      *
  950.      * @param int|null $userId the id of the profile to edit
  951.      *
  952.      * @return Response
  953.      *
  954.      * @throws \Psr\Container\ContainerExceptionInterface
  955.      * @throws \Psr\Container\NotFoundExceptionInterface
  956.      */
  957.     public function editAction(int $userId = null): Response
  958.     {
  959.         //only logged-in users can get the right to edit
  960.         //this is only a first check (see #493)
  961.         if (!$this->get('security.authorization_checker')->isGranted('ROLE_USER')) {
  962.             $url = $this->container->get('router')->generate('frontend_homepage');
  963.             return new RedirectResponse($url);
  964.         }
  966.         //we will always need to know the current user to be sure that not everybody can change another account
  967.         $user = $this->get('security.token_storage')->getToken()->getUser();
  969.         if ($userId == '') {
  970.             //this is the simplest case
  971.             //no userid is given so edit the profile from the person that is logged in
  972.             $userId = $user->getId();
  973.         }
  975.         //we want to edit an existing user, so this user must have an entry in the fos_user db
  976.         $fosUserData = $this->fosUserManager
  977.             ->findUserBy(
  978.                 array(
  979.                     'id'=>$userId
  980.                 )
  981.             );
  982.         if (!$fosUserData) {
  983.             //no such user, strange...
  984.             $message = "There is no user with this id ($userId).";
  985.             return $this->render(
  986.                 'Default/error.html.twig',
  987.                 array(
  988.                     'message' => $message
  989.                 )
  990.             );
  991.         }
  993.         //here it gets tricky
  994.         //who can edit, what profile??
  995.         if ($userId == $user->getId() //no problem, everybody can adapt his/here own profile
  996.             || $this->get('security.authorization_checker')->isGranted('ROLE_ADMIN')) //no problem, admin users can change the profiles of others
  997.         {
  998.             $em = $this->getDoctrine()->getManager();
  999.             $indiv =  $this->getDoctrine()
  1000.                 ->getRepository('OceanExpertBundle:Indiv')
  1001.                 ->findOneByIdInd($userId);
  1002.             if(!$indiv) {
  1003.                 //create a new profile as it does not exist yet
  1004.                 //this happens when people subscribe and want to complete their profile
  1006.                 $indiv = new Indiv();
  1007.                 $indiv->setTitle('');
  1008.                 $indiv->setFname('');
  1009.                 $indiv->setMname('');
  1010.                 $indiv->setSname('');
  1011.                 $indiv->setIdentifier('');
  1012.                 $indiv->setRegType('');
  1013.                 $indiv->setUseInstAddr(0);
  1014.                 $indiv->setPrivateAddress('');
  1015.                 $indiv->setAddr1('');
  1016.                 $indiv->setAddr2('');
  1017.                 $indiv->setCity('');
  1018.                 $indiv->setState('');
  1019.                 $indiv->setPostcode('');
  1020.                 $indiv->setIdNationality('');
  1021.                 $indiv->setTel('');
  1022.                 $indiv->setFax('');
  1023.                 $indiv->setEmail2('');
  1024.                 $indiv->setEmail3('');
  1025.                 $indiv->setUrl1('');
  1026.                 $indiv->setUrl2('');
  1027.                 $indiv->setUrl3('');
  1028.                 $indiv->setGender('');
  1029.                 $indiv->setLinkedin('');
  1030.                 $indiv->setFacebook('');
  1031.                 $indiv->setFlickr('');
  1032.                 $indiv->setTwitter('');
  1033.                 $indiv->setOther('');
  1034.                 $indiv->setDegree('');
  1035.                 $indiv->setActiveng('');
  1036.                 $indiv->setActivother('');
  1037.                 $indiv->setJobtitle('');
  1038.                 $indiv->setDept('');
  1039.                 $indiv->setStudyregion('');
  1040.                 $indiv->setLanguages('');
  1041.                 $indiv->setSkills('');
  1042.                 $indiv->setComments('');
  1043.                 $indiv->setDoNotInvite('');
  1044.                 $indiv->setAdminComments('');
  1045.                 $indiv->setIsGlobal(1);
  1046.                 $indiv->setStatus(0);
  1047.                 $indiv->setDeceased(0);
  1048.                 $indiv->setRetired(0);
  1049.                 $indiv->setIdInd($userId);
  1050.                 $indiv->setCountryCode(21);
  1052.                 //check email again and again
  1053.                 $fosUserEmail = $fosUserData->getEmail();
  1054.                 if (filter_var( $fosUserEmail, FILTER_VALIDATE_EMAIL)) {
  1055.                     $fosUserEmail = filter_var(
  1056.                         $fosUserEmail,
  1057.                         FILTER_SANITIZE_EMAIL
  1058.                     );
  1059.                 } else {
  1060.                     $message = "this ($fosUserEmail) is not a valid email address";
  1061.                     return $this->render(
  1062.                         'Default/error.html.twig',
  1063.                         array(
  1064.                             'message' => $message
  1065.                         )
  1066.                     );
  1067.                 }
  1068.                 $indiv->setEmail1($fosUserEmail);
  1070.                 $em->persist($indiv);
  1071.                 $em->flush();
  1072.             }
  1073.         } else {
  1074.             //this is not correct #491
  1075.             $message = 'You do not have the correct rights (your are not this person and you are not an admin user) to edit this profile.';
  1076.             return $this->render(
  1077.                 'Default/error.html.twig',
  1078.                 array(
  1079.                     'message' => $message
  1080.                 )
  1081.             );
  1082.         }
  1084.         $qb = $this->getDoctrine()
  1085.             ->getManager()
  1086.             ->createQueryBuilder();
  1088.         $qb->add('select', 'i, ins, p, c')
  1089.             ->add('from', 'OceanExpertBundle:Indiv i')
  1090.             ->leftJoin('OceanExpertBundle:ProfileImages', 'p', 'WITH', 'p.idInd = i.idInd')
  1091.             ->leftJoin('OceanExpertBundle:IndivInstitution', 'idins', 'WITH', 'i.idInd = idins.idInd')
  1092.             ->leftJoin('OceanExpertBundle:Institutions', 'ins', 'WITH', 'idins.idInst = ins.idInst')
  1093.             ->leftJoin('OceanExpertBundle:Countries', 'c', 'WITH', 'c.idCountry = i.countryCode')
  1094.             ->where('i.idInd = :userId')
  1095.             ->setParameter('userId', $userId);
  1097.         //get the expert data as far as we can find it
  1098.         $expert = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1099.         //dump($expert);
  1100.         //die();
  1102.         $metadata = $this->getMetaData($userId);
  1103.         $jobType = $this->getJobTypes($userId);
  1105.         $expert['jobType'] = $jobType['jobId'];
  1106.         $expert['userId'] = $userId;
  1107.         $expert['subjectArea'] = $this->getSubjectAreas($userId);
  1108.         $expert['roles'] = $fosUserData->getRoles();
  1109.         $expert['username'] = $fosUserData->getUsername();
  1110.         $expert['email'] = $fosUserData->getEmail();
  1112.         //get some data for the rest of the form
  1113.         $countries = $this->getDoctrine()
  1114.             ->getRepository('OceanExpertBundle:Countries')
  1115.             ->findBy(
  1116.                 [],
  1117.                 ['country' => 'ASC']
  1118.             );
  1119.         $locales = $this->getDoctrine()
  1120.             ->getRepository('OceanExpertBundle:Locale')
  1121.             ->findBy(
  1122.                 [],
  1123.                 ['locale' => 'ASC']
  1124.             );
  1125.         $studyregions = $this->getDoctrine()
  1126.             ->getRepository('OceanExpertBundle:Regions')
  1127.             ->findBy(
  1128.                 [],
  1129.                 ['name' => 'ASC']
  1130.             );
  1131.         $instituteSeaRegion = $this->getDoctrine()
  1132.             ->getRepository('OceanExpertBundle:Regions')
  1133.             ->seaRegions();
  1134.         $allSubjects = $this->getDoctrine()
  1135.             ->getRepository('OceanExpertBundle:Subjects')
  1136.             ->findBy(
  1137.                 [],
  1138.                 ['subname' => 'ASC']
  1139.             );
  1140.         $allJobtypes = $this->getDoctrine()
  1141.             ->getRepository('OceanExpertBundle:Jobtypes')
  1142.             ->findBy(
  1143.                 [],
  1144.                 ['idJob' => 'ASC']
  1145.             );
  1147.         //dump($expert);
  1148.         //die();
  1149.         return $this->render('Profile/editProfile.html.twig', array(
  1150.             'expert' => $expert,
  1151.             'countries' => $countries,
  1152.             'locales' => $locales,
  1153.             //is not used
  1154.             //'nationalities' => $countries,
  1155.             'metadata' => $metadata,
  1156.             'studyregions' => $studyregions,
  1157.             'availableSeaRegions' => $instituteSeaRegion,
  1158.             'allSubjects' => $allSubjects,
  1159.             'allJobtypes' => $allJobtypes
  1160.         ));
  1161.     }
  1163.     public function updateProfileTimeAction(Request $request): Response
  1164.     {
  1165.         $security_context = $this->get('security.authorization_checker');
  1166.         if ($security_context->isGranted('ROLE_USER')) {
  1167.             $userId = $request->request->get('userId');
  1168.             if ($userId) {
  1169.                 $indiv = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($userId);
  1170.                 if ($indiv) {
  1171.                     $indiv->setLDateUpd(new DateTime('now'));
  1172.                     $indiv->setLastEditBy($security_context->getToken()->getUser()->getId());
  1173.                     $em = $this->getDoctrine()->getManager();
  1174.                     $em->persist($indiv); //marks object to be saved in the next transaction.
  1175.                     $em->flush(); //performs all saves and transactions.
  1176.                 }
  1177.                 return new Response("updated successfully");
  1178.             } else {
  1179.                 return new Response("cannot update");
  1180.             }
  1181.         }
  1182.         return new Response("cannot update");
  1183.     }
  1185.     /**
  1186.      * activate the user with the given id
  1187.      *
  1188.      * @param int $userId
  1189.      *
  1190.      * @return JsonResponse
  1191.      */
  1192.     public function activateUserAction(int $userId): JsonResponse
  1193.     {
  1194.         $security_context = $this->get('security.authorization_checker');
  1196.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1197.             if ($userId) {
  1198.                 $indiv = $this->getDoctrine()
  1199.                     ->getRepository('OceanExpertBundle:Indiv')
  1200.                     ->findOneByIdInd($userId);
  1201.                 if ($indiv) {
  1202.                     $indiv->setStatus(1);
  1203.                     $indiv->setStatusLastChanged(new DateTime('now'));
  1204.                     $em = $this->getDoctrine()->getManager();
  1205.                     $em->persist($indiv); //marks object to be saved in the next transaction.
  1206.                     $em->flush(); //performs all saves and transactions.
  1207.                 }
  1208.                 return new JsonResponse(
  1209.                     array(
  1210.                         'status' => true,
  1211.                         'msg' => "updated successfully"
  1212.                     )
  1213.                 );
  1214.             } else {
  1215.                 return new JsonResponse(
  1216.                     array(
  1217.                         'status' => false,
  1218.                         'msg' => "cannot update"
  1219.                     )
  1220.                 );
  1221.             }
  1222.         }
  1223.         return new JsonResponse(
  1224.             array(
  1225.                 'status' => false,
  1226.                 'msg' => "you do not have sufficient privileges to perform this action"
  1227.             )
  1228.         );
  1229.     }
  1231.     /**
  1232.      * deactivate the user with the given id
  1233.      *
  1234.      * @param int $userId
  1235.      *
  1236.      * @return Response
  1237.      */
  1238.     public function deactivateUserAction($userId): Response
  1239.     {
  1240.         if (!$userId
  1241.             || $userId == ''
  1242.             || !is_numeric($userId)
  1243.         ) {
  1244.             $message[] = array(
  1245.                 'id' => $userId,
  1246.                 'status' => 0,
  1247.                 'message' => 'incorrect or no user id given'
  1248.             );
  1249.         }
  1250.         $userId = intval($userId);
  1252.         $security_context = $this->get('security.authorization_checker');
  1253.         $message = array();
  1255.         $authorId = $this->get('security.token_storage')
  1256.                 ->getToken()
  1257.                 ->getUser()
  1258.                 ->getId();
  1260.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')
  1261.             || $userId === $authorId
  1262.         ) {
  1264.             $em = $this->getDoctrine()->getManager();
  1266.             //disable the login
  1267.             $FOSUser = $em
  1268.                 ->getRepository('OceanExpertBundle:FosUser')
  1269.                 ->findOneById($userId);
  1270.             if ($FOSUser) {
  1271.                 $FOSUser->setEnabled(0);
  1272.                 $FOSUser->setUpdatedAt(new DateTime('now'));
  1273.                 $em->persist($FOSUser);
  1274.                 $em->flush();
  1275.             } else {
  1276.                 $message[] = array(
  1277.                     'id' => $userId,
  1278.                     'status' => 0,
  1279.                     'message' => "no user found in fos_user table with id $userId"
  1280.                 );
  1281.             }
  1283.             //deactivate the expert
  1284.             $indiv = $em
  1285.                 ->getRepository('OceanExpertBundle:Indiv')
  1286.                 ->findOneByIdInd($userId);
  1287.             if ($indiv) {
  1288.                 $comments = $indiv->getComments() . "this user($userId) has been deactivated by user with id $authorId ";
  1289.                 $indiv
  1290.                     ->setStatus(3)
  1291.                     ->setComments($comments)
  1292.                     ->setStatusLastChanged(new DateTime('now'));
  1293.                 $em->persist($indiv); //marks object to be saved in the next transaction.
  1294.                 $em->flush(); //performs all saves and transactions.
  1295.             } else {
  1296.                 $message[] = array(
  1297.                     'id' => $userId,
  1298.                     'status' => 0,
  1299.                     'message' => "no user found in indiv table with idInd $userId"
  1300.                 );
  1301.             }
  1303.             if (!count($message)) {
  1304.                 //no error messages yet so all should be fine
  1305.                 $message[] = array(
  1306.                     'id' => $userId,
  1307.                     'status' => true,
  1308.                     'message' => "user with idInd $userId deactivated"
  1309.                 );
  1310.             }
  1311.         } else {
  1312.             $message[] = array(
  1313.                 'id' => $userId,
  1314.                 'status' => 0,
  1315.                 'message' => 'you do not have enough rights to do this'
  1316.             );
  1317.         }
  1319.         return new JsonResponse($message);
  1320.     }
  1322.     public function getNationalityFromId($id)
  1323.     {
  1324.         $em = $this->getDoctrine()->getRepository('OceanExpertBundle:Nationality')->findOneById($id);
  1325.         if ($em == null) {
  1326.             return false;
  1327.         } else {
  1328.             return $em->getNationality();
  1329.         }
  1330.     }
  1332.     public function getCountryFromId($id)
  1333.     {
  1334.         $em = $this->getDoctrine()->getRepository('OceanExpertBundle:Countries')->findOneByIdCountry($id);
  1335.         if ($em == null) {
  1336.             return false;
  1337.         } else {
  1338.             return $em->getCountry();
  1339.         }
  1340.     }
  1342.     public function getCountryCodeFromId($id)
  1343.     {
  1344.         $em = $this->getDoctrine()
  1345.             ->getRepository('OceanExpertBundle:Countries')
  1346.             ->findOneByIdCountry($id);
  1347.         if ($em == null) {
  1348.             return false;
  1349.         } else {
  1350.             return $em->getCountryCode();
  1351.         }
  1352.     }
  1355.     /**
  1356.      * get the country info for the given id's or country codes
  1357.      *
  1358.      * @param array $countryArr
  1359.      *
  1360.      * @return array
  1361.      */
  1362.     public function getCountryFromIds(array $countryArr): array
  1363.     {
  1364.         $em = $this->getDoctrine()
  1365.             ->getRepository('OceanExpertBundle:Countries');
  1366.         $query = $em->createQueryBuilder('c')
  1367.             ->select('c.country, c.countryCode, c.longitude, c.latitude')
  1368.             ->where('c.idCountry in (:idCountry)')
  1369.             ->orWhere('c.countryCode in (:idCountry)')
  1370.             ->setParameter('idCountry', $countryArr)
  1371.             ->getQuery();
  1373.         return $query->getResult();
  1374.     }
  1377.     /**
  1378.      * @todo is this used???? Arno 06/09/24
  1379.      *
  1380.      * @param $value
  1381.      *
  1382.      * @return string
  1383.      */
  1384.     /*
  1385.     public function csvComma($value = '')
  1386.     {
  1388.         return "'" . implode("','", explode(",", $value)) . "'";
  1389.     }
  1390.     */
  1392.     public function getJobTypeByCodes($jobArr)
  1393.     {
  1394.         $em = $this->getDoctrine()
  1395.             ->getRepository('OceanExpertBundle:Jobtypes');
  1396.         $query = $em->createQueryBuilder('a')
  1397.             ->select('a.jobname')
  1398.             ->where('a.idJob in (:jobArr)')
  1399.             ->setParameter('jobArr', $jobArr)
  1400.             ->getQuery();
  1402.         $jobs = $query->getResult();
  1403.         $jobList = array_column($jobs, 'jobname');
  1404.         return implode(', ', $jobList);
  1405.     }
  1407.     public function getResearchAreaByCodes($codeArr)
  1408.     {
  1409.         $em = $this->getDoctrine()
  1410.             ->getRepository('OceanExpertBundle:Regions');
  1411.         $query = $em->createQueryBuilder('a')
  1412.             ->select('a.name')
  1413.             ->where('a.idRegion in (:codeArr)')
  1414.             ->setParameter('codeArr', $codeArr)
  1415.             ->getQuery();
  1417.         $regions = $query->getResult();
  1418.         $regionsList = array_column($regions, 'name');
  1419.         return implode(', ', $regionsList);
  1420.     }
  1422.     /**
  1423.      * get all the meta data for a given userId
  1424.      * this data comes as a key-value pair
  1425.      *
  1426.      * @param int $userId the userId of the expert
  1427.      *
  1428.      * @return array
  1429.      */
  1430.     public function getMetaData(int $userId): array
  1431.     {
  1432.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1433.         $qb->add('select', 'm.metaOption,m.metaValue')
  1434.             ->add('from', 'OceanExpertBundle:IndivMeta m')
  1435.             ->where('m.indivId = :userId')
  1436.             ->setParameter('userId', $userId);
  1438.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1439.         $metadata = array();
  1440.         foreach ($meta as $value) {
  1441.             $metadata[$value['metaOption']] = $value['metaValue'];
  1442.         }
  1443.         return $metadata;
  1444.     }
  1446.     /**
  1447.      * get all the different job types for a given userId
  1448.      *
  1449.      * @param int $userId the userId of the expert
  1450.      *
  1451.      * @return array
  1452.      */
  1453.     public function getJobTypes(int $userId): array
  1454.     {
  1455.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1456.         $qb->add('select', 'jt.jobname,jt.idJob')
  1457.             ->add('from', 'OceanExpertBundle:IndivJobtype j')
  1458.             ->leftJoin('OceanExpertBundle:Jobtypes', 'jt', 'WITH', 'jt.idJob = j.idJob')
  1459.             ->where('j.idInd = :userId')
  1460.             ->setParameter('userId', $userId);
  1462.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1463.         $jobTypes = implode(
  1464.             '\r',
  1465.             array_column(
  1466.                 $meta,
  1467.                 'jobname'
  1468.             )
  1469.         );
  1470.         $jobId = implode(
  1471.             ',',
  1472.             array_column(
  1473.                 $meta,
  1474.                 'idJob'
  1475.             )
  1476.         );
  1477.         return array(
  1478.             'jobtype' => $jobTypes,
  1479.             'jobId' => $jobId
  1480.         );
  1481.     }
  1483.     public function getUserGroups($userId)
  1484.     {
  1485.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1486.         $qb->add('select', 'g.groupname, g.idGroup')
  1487.             ->add('from', 'OceanExpertBundle:MemberGroups mg')
  1488.             ->leftJoin('OceanExpertBundle:Groups', 'g', 'WITH', 'mg.idGroup = g.idGroup')
  1489.             ->where('mg.idInd = :userId')
  1490.             ->setParameter('userId', $userId)
  1491.             ->orderBy('g.groupname','ASC');
  1493.         return $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1494.     }
  1496.     /**
  1497.      * get all the subject areas for a given userId
  1498.      *
  1499.      * @param int $userId the userId of the expert
  1500.      *
  1501.      * @return string
  1502.      */
  1503.     public function getSubjectAreas(int $userId): string
  1504.     {
  1505.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  1506.         $qb->add('select', 's.subname,s.idSub')
  1507.             ->add('from', 'OceanExpertBundle:IndivSubjects ivs')
  1508.             ->leftJoin('OceanExpertBundle:Subjects', 's', 'WITH', 's.idSub = ivs.idSub')
  1509.             ->where('ivs.idInd = :userId')
  1510.             ->setParameter('userId', $userId);
  1512.         $meta = $qb->getQuery()->getResult(AbstractQuery::HYDRATE_ARRAY);
  1513.         return implode(
  1514.             ',',
  1515.             array_column(
  1516.                 $meta,
  1517.                 'subname'
  1518.             )
  1519.         );
  1520.     }
  1522.     public function getUpdatedBy($id = '')
  1523.     {
  1524.         $updatedBy = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1525.         if ($updatedBy) {
  1526.             $name = $updatedBy->getfname() . " " . strtoupper($updatedBy->getsname());
  1527.         } else {
  1528.             $name = false;
  1529.         }
  1530.         return $name;
  1531.     }
  1533.     public function qccontrolAction(Request $request): Response
  1534.     {
  1535.         $id = $request->request->get('userId');
  1536.         $action = $request->request->get('action');
  1537.         $return = '';
  1538.         $security_context = $this->get('security.authorization_checker');
  1539.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1540.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1541.             $updatedBy = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1542.             if ($action == 1) {
  1543.                 $updatedBy->setQualityCheckedBy($author);
  1544.                 $updatedBy->setQualityCheckedDate(new DateTime('now'));
  1545.                 $updatedBy->setQualityChecked(1);
  1546.                 $return = "This record has been marked as quality controlled on <strong>" . date('F j, Y') . "</strong> by <strong>" . $this->getUpdatedBy($author)."</strong>";
  1547.             } else {
  1548.                 $updatedBy->setQualityCheckedBy(null);
  1549.                 $updatedBy->setQualityCheckedDate(null);
  1550.                 $updatedBy->setQualityChecked(0);
  1551.                 $return = "This record has not been quality controlled";
  1552.             }
  1553.             $updatedBy->setLDateUpd(new DateTime('now'));
  1554.             $updatedBy->setLastEditBy($author);
  1555.             $em = $this->getDoctrine()->getManager();
  1556.             $em->persist($updatedBy); //marks object to be saved in the next transaction.
  1557.             $em->flush(); //performs all saves and transactions.
  1558.         }
  1559.         return new Response($return);
  1560.     }
  1562.     public function setRetiredAction(Request $request): Response
  1563.     {
  1564.         $id = $request->request->get('userId');
  1565.         $date = $request->request->get('retiredDate');
  1567.         $retiredStatus = $request->request->get('retiredStatus');
  1568.         $security_context = $this->get('security.authorization_checker');
  1569.         if ($security_context->isGranted('ROLE_USER')) {
  1570.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1571.             $updateRecord = $this->getDoctrine()->getRepository('OceanExpertBundle:Indiv')->findOneByIdInd($id);
  1572.             if ($updateRecord) {
  1573.                 if ($retiredStatus == 1) {
  1574.                     $updateRecord->setRetired(1);
  1575.                     if (trim($date) == '') {
  1576.                         $updateRecord->setRetiredDate(null);
  1577.                     } else {
  1578.                         $updateRecord->setRetiredDate(DateTime::createFromFormat('Y-m-d', $date));
  1579.                     }
  1580.                 } else {
  1581.                     $updateRecord->setRetired(0);
  1582.                     $updateRecord->setRetiredDate(null);
  1583.                 }
  1584.             }
  1585.             $updateRecord->setLDateUpd(new DateTime('now'));
  1586.             $updateRecord->setLastEditBy($author);
  1587.             $em = $this->getDoctrine()->getManager();
  1588.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1589.             $em->flush(); //performs all saves and transactions.
  1590.         }
  1591.         return new Response($date);
  1592.     }
  1594.     public function setDeceasedAction(Request $request): Response
  1595.     {
  1596.         $id = $request->request->get('userId');
  1597.         $date = $request->request->get('deceasedDate');
  1598.         $deceasedStatus = $request->request->get('deceasedStatus');
  1599.         $return = '';
  1600.         $security_context = $this->get('security.authorization_checker');
  1601.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1602.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1603.             $updateRecord = $this->getDoctrine()
  1604.                 ->getRepository('OceanExpertBundle:Indiv')
  1605.                 ->findOneByIdInd($id);
  1606.             if ($updateRecord) {
  1607.                 if ($deceasedStatus == 1) {
  1608.                     $updateRecord->setDeceased(1);
  1609.                     if (trim($date) == '') {
  1610.                         $updateRecord->setDeceasedDate(null);
  1611.                     } else {
  1612.                         $updateRecord->setDeceasedDate(DateTime::createFromFormat('Y-m-d', $date));
  1613.                     }
  1614.                 } else {
  1615.                     $updateRecord->setDeceased(0);
  1616.                     $updateRecord->setDeceasedDate(null);
  1617.                 }
  1618.             }
  1619.             $updateRecord->setLDateUpd(new DateTime('now'));
  1620.             $updateRecord->setLastEditBy($author);
  1621.             $em = $this->getDoctrine()->getManager();
  1622.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1623.             $em->flush(); //performs all saves and transactions.
  1624.         }
  1625.         return new Response($return);
  1626.     }
  1628.     public function setDoNotInviteAction(Request $request): Response
  1629.     {
  1630.         $id = $request->request->get('userId');
  1631.         $status = $request->request->get('status');
  1632.         $return = '';
  1633.         $security_context = $this->get('security.authorization_checker');
  1634.         if ($security_context->isGranted('ROLE_USER')) {
  1635.             $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1636.             $updateRecord = $this->getDoctrine()
  1637.                 ->getRepository('OceanExpertBundle:Indiv')
  1638.                 ->findOneByIdInd($id);
  1639.             if ($updateRecord) {
  1640.                 if ($status == 1) {
  1641.                     $updateRecord->setDoNotInvite(1);
  1642.                     $updateRecord->setDoNoInviteBy($author);
  1643.                     $updateRecord->setDoNoInviteOn(new DateTime('now'));
  1644.                     $return = 'This record has been set as do not invite on <strong>' . date('F j, Y') . '</strong>';
  1645.                     $return .= 'by <strong>' . $this->getUpdatedBy($author) . '</strong>';
  1646.                 } else {
  1647.                     $updateRecord->setDoNotInvite(0);
  1648.                     $updateRecord->setDoNoInviteBy(0);
  1649.                     $updateRecord->setDoNoInviteOn(NULL);
  1650.                     $return = 'Please select "Yes" to add this member to the do not invite list.';
  1651.                 }
  1652.             }
  1653.             $updateRecord->setLDateUpd(new DateTime('now'));
  1654.             $updateRecord->setLastEditBy($author);
  1655.             $em = $this->getDoctrine()->getManager();
  1656.             $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1657.             $em->flush(); //performs all saves and transactions.
  1658.         }
  1659.         return new Response($return);
  1660.     }
  1662.     public function setAdmincommentsAction(Request $request): Response
  1663.     {
  1664.         $id = $request->request->get('userId');
  1665.         $comments = $request->request->get('comments');
  1666.         $return = '';
  1667.         if (trim($comments) != '') {
  1668.             $security_context = $this->get('security.authorization_checker');
  1669.             if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1670.                 $author = $this->get('security.token_storage')->getToken()->getUser()->getId();
  1671.                 $updateRecord = $this->getDoctrine()
  1672.                     ->getRepository('OceanExpertBundle:Indiv')
  1673.                     ->findOneByIdInd($id);
  1674.                 $comments .= '<br />';
  1675.                 $comments .= '(Added by ' . $this->getUpdatedBy($author);
  1676.                 $comments .= ' on ' . date('d-m-y');
  1677.                 $comments .= ')<br /><br />';
  1678.                 $comments .= $updateRecord->getAdminComments();
  1679.                 if ($updateRecord) {
  1680.                     $updateRecord->setAdminComments($comments);
  1681.                 }
  1682.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1683.                 $updateRecord->setLastEditBy($author);
  1684.                 $em = $this->getDoctrine()->getManager();
  1685.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1686.                 $em->flush(); //performs all saves and transactions.
  1687.                 $return = $comments;
  1688.             }
  1689.         }
  1690.         return new Response($return);
  1691.     }
  1693.     public function setGroupsAction(Request $request): Response
  1694.     {
  1695.         $id = $request->request->get('userId');
  1696.         $groups = $request->request->get('groups');
  1697.         $return = '';
  1698.         $security_context = $this->get('security.authorization_checker');
  1699.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1700.             $author = $this->get('security.token_storage')
  1701.                 ->getToken()
  1702.                 ->getUser()
  1703.                 ->getId();
  1704.             $updateRecord = $this->getDoctrine()
  1705.                 ->getRepository('OceanExpertBundle:Indiv')
  1706.                 ->findOneByIdInd($id);
  1707.             if ($updateRecord) {
  1708.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1709.                 $updateRecord->setLastEditBy($author);
  1710.                 $em = $this->getDoctrine()->getManager();
  1711.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1712.                 $em->flush(); //performs all saves and transactions.
  1713.             }
  1714.             if (is_array($groups)) {
  1715.                 $em = $this->getDoctrine()->getManager();
  1716.                 $results = $em->createQueryBuilder()
  1717.                     ->add('select', 'm')
  1718.                     ->add('from', 'OceanExpertBundle:MemberGroups m')
  1719.                     ->where('m.idGroup not in (:groups)')
  1720.                     ->andWhere('m.idInd =:idInd')
  1721.                     ->setParameters(array('groups' => $groups, 'idInd' => $id))
  1722.                     ->getQuery()->getResult();
  1724.                 foreach ($results as $result) {
  1725.                     $em->remove($result);
  1726.                 }
  1727.                 $em->flush();
  1729.                 foreach ($groups as $value) {
  1730.                     $updateGroup = $this->getDoctrine()
  1731.                         ->getRepository('OceanExpertBundle:MemberGroups')
  1732.                         ->find(
  1733.                             array(
  1734.                                 'idInd' => $id,
  1735.                                 'idGroup' => $value
  1736.                             )
  1737.                         );
  1738.                     if (!$updateGroup) {
  1739.                         $addGroups = new MemberGroups();
  1740.                         $addGroups->setIdInd($id);
  1741.                         $addGroups->setIdGroup($value);
  1742.                         $addGroups->setRole('');
  1743.                         $addGroups->setMemberOrder(NULL);
  1744.                         $addGroups->setIsLeader(0);
  1745.                         $em = $this->getDoctrine()->getManager();
  1746.                         $em->persist($addGroups); //marks object to be saved in the next transaction.
  1747.                         $em->flush(); //performs all saves and transactions.
  1748.                     }
  1749.                 }
  1750.             } else {
  1751.                 $updateGroup = $this->getDoctrine()
  1752.                     ->getRepository('OceanExpertBundle:MemberGroups')
  1753.                     ->findBy(array('idInd' => $id));
  1754.                 $em = $this->getDoctrine()->getEntityManager();
  1755.                 foreach ($updateGroup as $groups) {
  1756.                     $em->remove($groups);
  1757.                 }
  1758.                 $em->flush();
  1759.             }
  1760.         }
  1761.         return new Response($return);
  1762.     }
  1764.     public function setPrivilegesAction(Request $request): Response
  1765.     {
  1766.         //get all the values from the request
  1767.         //these values are send from profile.html.twig $("#addPrivileges").click(function () {....
  1768.         $id = $request->request->get('userId');
  1769.         $countries = $request->request->get('countries');
  1770.         $ownInstitute = $request->request->get('ownInstitute');
  1771.         $countryList = $request->request->get('countryList');
  1772.         $editor = $request->request->get('editor');
  1775.         $security_context = $this->get('security.authorization_checker');
  1776.         if ($security_context->isGranted('ROLE_GLOBAL_EDITOR')) {
  1777.             $return = array(
  1778.                 'status' => 0,
  1779.                 'message' => array()
  1780.             );
  1781.             //who is doing this update
  1782.             $author = $this->get('security.token_storage')
  1783.                 ->getToken()
  1784.                 ->getUser()
  1785.                 ->getId();
  1787.             //what record needs to be updated
  1788.             $updateRecord = $this->getDoctrine()
  1789.                 ->getRepository('OceanExpertBundle:Indiv')
  1790.                 ->findOneByIdInd($id);
  1791.             if ($updateRecord) {
  1792.                 $updateRecord->setLDateUpd(new DateTime('now'));
  1793.                 $updateRecord->setLastEditBy($author);
  1794.                 $em = $this->getDoctrine()->getManager();
  1795.                 $em->persist($updateRecord); //marks object to be saved in the next transaction.
  1796.                 $em->flush(); //performs all saves and transactions.
  1797.             }
  1799.             if ($ownInstitute == 1) {
  1800.                 $updateInstEdit = $this->getDoctrine()
  1801.                     ->getRepository('OceanExpertBundle:MemberEditsInstitution')
  1802.                     ->findOneBy(array(
  1803.                             'idInd' => $id,
  1804.                             'idInst' => $this->getIndivInstitute($id)
  1805.                         )
  1806.                     );
  1807.                 if (!$updateInstEdit) {
  1808.                     $updateInstEdit = new MemberEditsInstitution();
  1809.                     $updateInstEdit->setIdInd($id);
  1810.                     $updateInstEdit->setIdInst($this->getIndivInstitute($id));
  1811.                 } else {
  1812.                     $updateInstEdit->setIdInst($this->getIndivInstitute($id));
  1813.                 }
  1814.                 $em->persist($updateInstEdit); //marks object to be saved in the next transaction.
  1815.                 $em->flush(); //performs all saves and transactions.
  1816.                 $return['message'][] = 'update own institute activated';
  1817.             } else {
  1818.                 $qb = $em->createQueryBuilder();
  1819.                 $query = $qb->delete('OceanExpertBundle:MemberEditsInstitution', 'm')
  1820.                     ->where('m.idInd = :id')
  1821.                     ->andWhere('m.idInst = :idInst')
  1822.                     ->setParameters(
  1823.                         array(
  1824.                             'id' => $id,
  1825.                             'idInst' => $this->getIndivInstitute($id)
  1826.                         )
  1827.                     )
  1828.                     ->getQuery();
  1829.                 $query->execute();
  1830.                 $em->flush();
  1831.                 $return['message'][] = 'update own institute removed';
  1832.             }
  1833.             if (is_array($countries)
  1834.                 && $countryList == 1
  1835.             ) {
  1836.                 $em = $this->getDoctrine()->getManager();
  1837.                 $results = $em->createQueryBuilder()
  1838.                     ->add('select', 'm')
  1839.                     ->add('from', 'OceanExpertBundle:MemberEditsCountry m')
  1840.                     ->where('m.idCountry not in (:countries)')
  1841.                     ->andWhere('m.idInd =:idInd')
  1842.                     ->setParameters(
  1843.                         array(
  1844.                             'countries' => $countries,
  1845.                             'idInd' => $id
  1846.                         )
  1847.                     )
  1848.                     ->getQuery()->getResult();
  1850.                 foreach ($results as $result) {
  1851.                     $em->remove($result);
  1852.                 }
  1853.                 $em->flush();
  1855.                 foreach ($countries as $value) {
  1856.                     $updateCountries = $this->getDoctrine()
  1857.                         ->getRepository('OceanExpertBundle:MemberEditsCountry')
  1858.                         ->find(array(
  1859.                                 'idInd' => $id,
  1860.                                 'idCountry' => $value
  1861.                             )
  1862.                         );
  1863.                     if (!$updateCountries) {
  1864.                         $addCountry = new MemberEditsCountry();
  1865.                         $addCountry->setIdInd($id);
  1866.                         $addCountry->setIdCountry($value);
  1867.                         $em = $this->getDoctrine()->getManager();
  1868.                         $em->persist($addCountry); //marks object to be saved in the next transaction.
  1869.                         $em->flush(); //performs all saves and transactions.
  1870.                     }
  1871.                 }
  1872.                 $return['message'][] = 'countries added';
  1873.             } else {
  1874.                 $updateGroup = $this->getDoctrine()
  1875.                     ->getRepository('OceanExpertBundle:MemberEditsCountry')
  1876.                     ->findBy(array('idInd' => $id));
  1877.                 $em = $this->getDoctrine()->getEntityManager();
  1878.                 foreach ($updateGroup as $groups) {
  1879.                     $em->remove($groups);
  1880.                 }
  1881.                 $em->flush();
  1882.                 $return['message'][] = 'countries removed';
  1883.             }
  1886.             $user= $em->getRepository('OceanExpertBundle:User')
  1887.                 ->findOneBy(
  1888.                     array(
  1889.                         'id' => $id
  1890.                     )
  1891.                 );
  1892.             if($editor == 1) {
  1893.                 $user->addRole("ROLE_GLOBAL_EDITOR");
  1894.                 $return['message'][] = 'global editor activated';
  1895.             } elseif ($editor == 0) {
  1896.                 $user->removeRole('ROLE_GLOBAL_EDITOR');
  1897.                 $return['message'][] = 'global editor removed';
  1898.             }
  1899.             $em->persist($user);
  1900.             $em->flush();
  1902.         } else {
  1903.             $return = array(
  1904.                 'status' => 1,
  1905.                 'error' => 'you have no rights to do this'
  1906.             );
  1907.         }
  1908.         return new Response(json_encode($return));
  1909.     }
  1911.     public function resetPasswordLinkAction(Request $request): Response
  1912.     {
  1913.         if ($request->query->get('username')) {
  1914.             $username = $request->query->get('username');
  1915.         } else {
  1916.             $username = $request->request->get('username');
  1917.         }
  1919.         $user = $this->fosUserManager->findUserByUsernameOrEmail($username);
  1921.         if (null === $user) {
  1922.             $return = "Error in sending email. User not found.";
  1923.             return new Response($return);
  1924.         }
  1926.         if (null === $user->getConfirmationToken()) {
  1927.             $user->setConfirmationToken($this->fosTokenGenerator->generateToken());
  1928.         }
  1930.         $this->fosMailer->sendResettingEmailMessage($user);
  1931.         $user->setPasswordRequestedAt(new DateTime());
  1932.         $this->fosUserManager->updateUser($user);
  1933.         $return = "Password reset link send successfully.";
  1934.         if ($request->query->get('username')) {
  1935.             $email = $user->getEmail();
  1936.             if (false !== $pos = strpos($email, '@')) {
  1937.                 $email = '...' . substr($email, $pos);
  1938.             }
  1939.             return new RedirectResponse(
  1940.                 $this->generateUrl(
  1941.                     'fos_user_resetting_check_email',
  1942.                     array('email' => $email)
  1943.                 )
  1944.             );
  1945.         }
  1947.         return new Response($return);
  1948.     }
  1950.     public function getIndivInstitute($idInd)
  1951.     {
  1952.         $getInstId = $this->getDoctrine()
  1953.             ->getRepository('OceanExpertBundle:IndivInstitution')
  1954.             ->findOneByIdInd($idInd);
  1955.         if ($getInstId) {
  1956.             return $getInstId->getIdInst();
  1957.         } else {
  1958.             return 0;
  1959.         }
  1960.     }
  1962.     /**
  1963.      * @return Response
  1964.      */
  1965.     public function assignRolesAction(Request $request): Response
  1966.     {
  1967.         $username =  $request->request->get('username');
  1969.         $allAssignedRoles = array();
  1970.         $allRevokedRoles = array();
  1972.         $em = $this->getDoctrine()->getManager();
  1973.         $user= $em->getRepository("OceanExpertBundle:User")
  1974.             ->findOneBy(
  1975.                 array(
  1976.                     'username' => $username
  1977.                 )
  1978.             );
  1980.         if ($request->request->get('superadmin')==1) {
  1981.             $user->addRole('ROLE_SUPERADMIN');
  1982.             $allAssignedRoles[] = 'ROLE_SUPERADMIN';
  1983.         } else {
  1984.             $user->removeRole('ROLE_SUPERADMIN');
  1985.             $allRevokedRoles[] = 'ROLE_SUPERADMIN';
  1986.         }
  1987.         if ($request->request->get('oceancdadmin')==1) {
  1988.             $user->addRole('ROLE_OCEANCD');
  1989.             $allAssignedRoles[] = 'ROLE_OCEANCD';
  1990.         } else {
  1991.             $user->removeRole('ROLE_OCEANCD');
  1992.             $allRevokedRoles[] = 'ROLE_OCEANCD';
  1993.         }
  1994.         if ($request->request->get('odiscatadmin')==1) {
  1995.             $user->addRole('ROLE_ODISCATADMIN');
  1996.             $allAssignedRoles[] = 'ROLE_ODISCATADMIN';
  1997.         } else {
  1998.             $user->removeRole('ROLE_ODISCATADMIN');
  1999.             $allRevokedRoles[] = 'ROLE_ODISCATADMIN';
  2000.         }
  2001.         if ($request->request->get('administrator')==1) {
  2002.             $user->addRole('ROLE_ADMIN');
  2003.             $allAssignedRoles[] = 'ROLE_ADMIN';
  2004.         } else {
  2005.             $user->removeRole('ROLE_ADMIN');
  2006.             $allRevokedRoles[] = 'ROLE_ADMIN';
  2007.         }
  2008.         if ($request->request->get('manager')==1) {
  2009.             $user->addRole('ROLE_MANAGER');
  2010.             $allAssignedRoles[] = 'ROLE_MANAGER';
  2011.         } else {
  2012.             $user->removeRole('ROLE_MANAGER');
  2013.             $allRevokedRoles[] = 'ROLE_MANAGER';
  2014.         }
  2015.         if ($request->request->get('lme')==1) {
  2016.             $user->addRole('ROLE_LME');
  2017.             $allAssignedRoles[] = 'ROLE_LME';
  2018.         } else {
  2019.             $user->removeRole('ROLE_LME');
  2020.             $allRevokedRoles[] = 'ROLE_LME';
  2021.         }
  2022.         $em->persist($user);
  2023.         $em->flush();
  2025.         return new JsonResponse(
  2026.             array(
  2027.                 'status' => 1 ,
  2028.                 'message' => 'Role(s) assigned successfully',
  2029.                 'username' => $username,
  2030.                 'assigned' => implode(',', $allAssignedRoles),
  2031.                 'revoked' => implode(', ', $allRevokedRoles),
  2032.                 'user' => $user
  2033.             )
  2034.         );
  2035.     }
  2037.     /**
  2038.      * @return JsonResponse
  2039.      */
  2040.     public function getExpertsAjaxAction(Request $request): Response
  2041.     {
  2042.         if (!null == $request->query->get('q')) {
  2043.             $query = $request->query->get('q');
  2044.             $em = $this->getDoctrine()->getManager();
  2045.             $connection = $em->getConnection();
  2046.             $statement = $connection->prepare("SELECT 
  2047.                 i.id_ind AS id, 
  2048.                 i.fname, 
  2049.                 i.sname, 
  2050.                 i.jobtitle,
  2051.                 inst.inst_name,
  2052.                 c.country 
  2053.             FROM indiv i
  2054.             LEFT JOIN countries c ON c.id_country =  i.country_code
  2055.             LEFT JOIN indiv_institution ii ON ii.id_ind = i.id_ind
  2056.             LEFT JOIN institutions inst ON inst.id_inst = ii.id_inst
  2057.             LEFT JOIN countries ic ON ic.id_country =  inst.country_code
  2058.             WHERE ( MATCH (fname,sname) AGAINST (:searchterm IN BOOLEAN MODE) 
  2059.                 OR fname like '%$query%' 
  2060.                 OR fname like '%$query%' 
  2061.                 OR sname like '%$query%' 
  2062.                 OR sname like '%$query%') 
  2063.                 AND status = 1;
  2064.             ");
  2065.             $statement->bindValue('searchterm', $query);
  2066.             $statement->execute();
  2067.             $query = $statement->fetchAll();
  2069.             $data = array();
  2070.             if($query) {
  2071.                 $data = array(
  2072.                     'incomplete_results' => false,
  2073.                     'items' => $query,
  2074.                     'total_count' => count($query),
  2075.                 );
  2076.             }
  2078.             return new JsonResponse($data);
  2079.         }
  2080.         return new JsonResponse(array());
  2081.     }
  2083.     /**
  2084.      * @param int     $idInd
  2085.      * @param Request $request
  2086.      *
  2087.      * @return mixed
  2088.      */
  2089.     function getExpertEventParticipation(int $idInd, Request $request) {
  2090.         $em = $this->getDoctrine()->getManager();
  2091.         $participation = $em->createQueryBuilder()
  2092.             ->add('select', 'ep.idEvent')
  2093.             ->add('from', 'OceanExpertBundle:EventParticipants ep')
  2094.             ->where('ep.idInd =:idInd')
  2095.             ->setParameters(array('idInd' => $idInd ))
  2096.             ->getQuery()->getResult();
  2097.         $participation = array_column($participation, "idEvent");
  2098.         $contacts = $em->createQueryBuilder()
  2099.             ->add('select', 'ec.idEvent')
  2100.             ->add('from', 'OceanExpertBundle:EventContacts ec')
  2101.             ->where('ec.idInd =:idInd')
  2102.             ->setParameters(array('idInd' => $idInd ))
  2103.             ->getQuery()->getResult();
  2104.         $contacts = array_column($contacts, "idEvent");
  2105.         $staff = $em->createQueryBuilder()
  2106.             ->add('select', 'es.idEvent')
  2107.             ->add('from', 'OceanExpertBundle:EventStaff es')
  2108.             ->where('es.idInd =:idInd')
  2109.             ->setParameters(array('idInd' => $idInd ))
  2110.             ->getQuery()->getResult();
  2111.         $staff = array_column($staff, "idEvent");
  2112.         $results = array_merge($participation,$contacts,$staff);
  2113.         $results = array_unique($results);
  2115.         $qb = $this->getDoctrine()->getManager()->createQueryBuilder();
  2116.         $qb->add('select', 'e.idEvent, e.title, e.idEventtype, e.startOn, e.endOn, e.address, e.city, e.state, e.postcode, c.country')
  2117.             ->add('from', 'OceanExpertBundle:Events e')
  2118.             ->leftJoin('OceanExpertBundle:Countries', 'c', 'WITH', 'e.idCountry = c.idCountry')
  2119.             ->where('e.idEvent in (:idEvent)')
  2120.             ->andWhere('e.status = 1')
  2121.             ->orderBy('e.startOn', 'DESC')
  2122.             ->setParameter('idEvent', $results );
  2123.         $resultData = $qb->getQuery()->getResult();
  2125.         $paginator = $this->get('knp_paginator');
  2126.         $members = $paginator->paginate(
  2127.             $resultData,
  2128.             $request->query->getInt('page', 1),
  2129.             5,
  2130.             array(
  2131.                 'pageParameterName' => 'page',
  2132.                 'sortDirectionParameterName' => 'dir'
  2133.             )
  2134.         );
  2136.         //@todo some code goes here (i.e. your symfony request dispatching)
  2138.         return $members;
  2139.     }
  2140. }