src/Controller/SearchAuthorsController.php line 216

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  6. use App\Entity\Author;
  7. use App\Entity\Follow;
  8. use App\Entity\Journal;
  9. use App\Entity\User;
  10. use App\Manager\PublicationManager;
  11. use App\Service\Sortpublication;
  12. use Doctrine\ORM\EntityManagerInterface;
  13. use Knp\Component\Pager\PaginatorInterface;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  16. use Symfony\Component\HttpClient\HttpClient;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\Routing\Annotation\Route;
  20. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  22. class SearchAuthorsController extends AbstractController
  23. {
  25.     /** @var EntityManagerInterface */
  26.     private $entityManager;
  28.     /** @var LoggerInterface */
  29.     private $logger;
  31.     /**
  32.      * SearchAuthorsController constructor.
  33.      *
  34.      * @param EntityManagerInterface $entityManager
  35.      * @param LoggerInterface $logger
  36.      */
  37.     public function __construct(EntityManagerInterface $entityManager, LoggerInterface $logger)
  38.     {
  39.         $this->entityManager = $entityManager;
  40.         $this->logger = $logger;
  41.     }
  44.     /**
  45.      * @Route("/authors" ,name="get_authors")
  46.      *
  47.      * find the authors
  48.      */
  49.     public function callapi(Request $request,PaginatorInterface $paginator)
  50.     {
  51.         ini_set('max_execution_time', -1);
  52.         $exist=null;
  53.         $followers=[];
  54.         $manyRequests=false;
  55.         $entityManager = $this->getDoctrine()->getManager();
  56.         $auteur = trim($request->get('authorValue'));
  57.         if($auteur==''){
  58.             $requestUri=$request->getRequestUri();
  59.             if (strpos($requestUri, 'authorValue') !== false) {
  60.                    return $this->redirect('/');
  61.             }
  62.         }
  63.         $checkFollowing=$entityManager->getRepository(Follow::class)->findOneBy(['following'=>trim($auteur)]);
  64.         $author_db=$entityManager->getRepository(User::class)->findBy(['fullName'=>$auteur]);
  66.         if($author_db){
  67.             $author_db=$author_db[0];
  68.         }
  69.         if($checkFollowing){
  70.             $followers=$checkFollowing->getFollowers()->getValues();
  71.             foreach ($followers as $follower){
  72.                     if ($follower &&  $this->getUser() && $follower->getId() == $this->getUser()->getId()) {
  73.                         $exist = 1;
  74.                     }
  75.             }
  76.         }
  78.         $countFollowers=count($followers);
  79.         $allFollowers=$entityManager->getRepository(Follow::class)->findAll();
  80.         $test=false;
  81.         if (strpos($request->getUri(), 'authorValue') !== false){
  82.             $test=true;
  83.         }
  84.         $param  = urlencode($auteur); // str_replace(' ','+',$auteur);
  85.         $data = null;
  87.         $authors=[];
  88.         $array_crossref = array();
  89.         $total=0;
  90.             $param  = urlencode($auteur);
  94. //---------------------------------------------
  95.         $checkAuteur=$entityManager->getRepository(Author::class)->searchAuteurByName($auteur);
  96.         if($checkAuteur) {
  97.             foreach ($checkAuteur as $auteur){
  98.                 $auteurName=$auteur->getName();
  99.                 $count=0;
  100.                 $checkFollowingAuteurName=$entityManager->getRepository(Follow::class)->findOneBy(['following'=>trim($auteurName)]);
  101.                 if($checkFollowingAuteurName) {
  102.                     $count = count($checkFollowingAuteurName->getFollowers()->getValues());
  103.                 }
  104.                 $array_crossref[]=['name'=>strtolower($auteurName),'count'=>$count];
  105.             }
  106.             $array_crossref = array_map("unserialize", array_unique(array_map("serialize", $array_crossref)));
  107.         }
  108.         else {
  109.             $urlOpenAlex = "https://api.openalex.org/authors?per-page=100&page=1&search=$auteur";
  110.             $rawData = HttpClient::create()
  111.                 ->request('GET', $urlOpenAlex);
  112.             if ($rawData->getStatusCode() === 200) {
  113.                 $rawData = $rawData->getContent();
  114.                 $data = \json_decode($rawData);
  115.                 if ($data) {
  116.                     $data = $data->results;
  117.                     foreach ($data as $author){
  118.                         $auteurName=$author->display_name;
  119.                         $count=0;
  120.                         $checkFollowingAuteurName=$entityManager->getRepository(Follow::class)->findOneBy(['following'=>trim($auteurName)]);
  121.                         if($checkFollowingAuteurName) {
  122.                             $count = count($checkFollowingAuteurName->getFollowers()->getValues());
  123.                         }
  124.                         $array_crossref[]=['name'=>strtolower($auteurName),'count'=>$count];
  125.                         // delete doublons in array crossref by name
  126.                     }
  127.                     $array_crossref = array_map("unserialize", array_unique(array_map("serialize", $array_crossref)));
  128.                 }
  129.             }else{
  130.                 try {
  131.                     $rawData = HttpClient::create()
  132.                         ->request('GET', "https://api.crossref.org/works?query.author=$auteur&rows=40");
  133.                     if ($rawData->getStatusCode() === 200) {
  134.                         $rawData = $rawData->getContent();
  135.                         $data = \json_decode($rawData);
  136.                         if (isset($data->message->items)) {
  137.                             $articles = $data->message->items;
  138.                             foreach ($articles as $article) {
  139.                                 $auteurs = $article->author;
  140.                                 foreach ($auteurs as $aut) {
  141.                                     $family = '';
  142.                                     $firstname = '';
  143.                                     $auteurName = '';
  144.                                     $total = 0;
  145.                                     if (isset($aut->given)) {
  146.                                         $firstname = $aut->given;
  147.                                     }
  148.                                     if (isset($aut->family) && strtolower($aut->family) != strtolower($firstname)) {
  149.                                         $family = $aut->family;
  150.                                     }
  151.                                     if ($family != '' && $firstname != '') {
  152.                                         $auteurName = $firstname . ' ' . $family;
  153.                                     } elseif ($family != '') {
  154.                                         $auteurName = $family;
  155.                                     } elseif ($firstname != '') {
  156.                                         $auteurName = $firstname;
  157.                                     }
  158.                                     if ($auteurName
  159.                                         && !in_array(strtolower($auteurName), array_column($array_crossref, 'name'))
  160.                                         && strpos(strtolower($auteurName), strtolower($auteur)) !== false) {
  161.                                         $count = 0;
  162.                                         $checkFollowingAuteurName = $entityManager->getRepository(Follow::class)->findOneBy(['following' => trim($auteurName)]);
  163.                                         if ($checkFollowingAuteurName) {
  164.                                             $count = count($checkFollowingAuteurName->getFollowers()->getValues());
  165.                                         }
  166.                                         $array_crossref[] = ['name' => strtolower($auteurName), 'count' => $count];
  168.                                     }
  169.                                 }
  170.                             }
  171.                         }
  172.                     }
  175.                 } catch (TransportExceptionInterface $e) {
  176.                 }
  177.             }
  178.         }
  180. //---------------------------------------------
  183.         sort($array_crossref);
  184.         $page = $request->get("p", 1);
  185.         $perpage = 10;
  186.         $authors = $paginator->paginate($array_crossref, $page, 10);
  187.         $total = count($array_crossref);
  188.         // sort array_crossref by name
  189.         usort($array_crossref, function($a, $b) {
  190.             return $a['name'] <=> $b['name'];
  191.         });
  192.         $pages=ceil($total/$perpage);
  194.         return $this->render('refonte/authors/authors-crossref.html.twig',
  195.             [
  196.                 'data'=> $data,
  197.                 'parametre'=>$test,
  198.                 'exist'=>$exist,
  199.                 'countFollowers'=>$countFollowers,
  200.                 'allFollowers'=>$allFollowers,
  201.                 'array_crossref'=>$authors,
  202.                 'total'=>$total,
  203.                 'author_db'=>$author_db,
  204.                 'manyRequests'=>$manyRequests,
  205.                 "auteur"=>$auteur,
  206.                 "pages"=>$pages,
  207.                 "page"=>$page
  208.             ]);
  209.     }
  211.     /**
  212.      * @Route("/authors/publication" ,name="get_authors_publication")
  213.      *
  214.      * find a publications of author
  215.      */
  216.     public function callpubapi(Request $request,PublicationManager $publicationManager){
  217.         if(!$this->getUser()){
  218.             $this->addFlash('info', 'You must be logged in to access this page');
  219.             return $this->redirectToRoute('registre_user');
  220.         }
  221.         ini_set('default_socket_timeout', -1);
  222.         $exist=null;$followers=[];
  223.         $auteur = trim($request->get('auteur'));
  224.         $checkFollowing=$this->entityManager->getRepository(Follow::class)->findOneBy(['following'=>$auteur]);
  225.         $authorDB = $this->entityManager->getRepository(User::class)->findOneBy(['fullName'=>$auteur]);
  226.         $publications=[];
  227.         $suggestedJournals=[];
  228.         $selectedAuthors=[];
  229.         $authorList=[];
  230.         if($checkFollowing){
  231.             $followers=$checkFollowing->getFollowers()->getValues();
  232.             foreach ($followers as $follower){
  233.                 if ($follower && $this->getUser() ){
  234.                     if($follower->getId() == $this->getUser()->getId()) {
  235.                         $exist=1;
  236.                     }
  237.                 }
  238.             }
  239.         }
  240.         $countFollowers=count($followers);
  241.         $param=str_replace(' ','+',$auteur);
  242.         $param  = urlencode($auteur); // str_replace(' ','+',$auteur);
  243.         $search=false;
  244.         $data = null;
  245.         $authors1=[];
  246.         $authors2=[];
  247.         $dd1 = [];
  248.         $array = [];
  249.         $author_db = [];
  250.         $co_authors = [];
  251.         $fullName = [];
  252.         $manyRequests=false;
  253.         $gender='';
  255.         $institution='';
  256.         $country='';
  257.         $topics=[];
  258.         if(isset($data->result->hits->hit)){
  259.                 $search=true;
  260.         }
  261.         // get gender of author
  262. //        $client = HttpClient::create();
  263. //        $response = $client->request('GET', 'https://api.genderize.io', [
  264. //            'query' => [
  265. //                'name' => $auteur
  266. //            ]
  267. //        ]);
  268. //        $statusCode = $response->getStatusCode();
  269. //        if ($statusCode === 200) {
  270. //            $content = $response->toArray();
  271. //            $gender = $content['gender'];
  272. //        }
  273.             // get gender of author end
  276.         $worksData = HttpClient::create()
  277.                 ->request('GET', "https://api.crossref.org/works?query.author=$auteur");
  278. //                ->request('GET', "https://api.crossref.org/works?query.bibliographic=$auteur&query.author=$auteur");
  279.         $urlOpenAlex = "https://api.openalex.org/authors?search=$auteur&per-page=100&page=1";
  281.         $rawData = HttpClient::create()
  282.             ->request('GET', $urlOpenAlex);
  284.            if ($rawData->getStatusCode() === 200) {
  285.             $authorOpenAlex = [];
  286. //            if ($rawData->getStatusCode() === 200) {
  287.                 $rawData = $rawData->getContent();
  288.                 $data = \json_decode($rawData);
  289.                 if ($data) {
  290.                     $data = $data->results;
  291.                     foreach ($data as $authortop) {
  292.                         $auteurName = strtolower($authortop->display_name);
  293.                         if($auteurName==strtolower($auteur) && !in_array($auteurName,$authorOpenAlex)){
  294.                             $authorOpenAlex = $authortop;
  295.                             break;
  296.                         }
  297.                     }
  298.                     if($authorOpenAlex){
  299.                         $works=$authorOpenAlex->works_api_url."&per-page=200";
  300.                         $rawData = HttpClient::create()
  301.                             ->request('GET', $works);
  302.                         if ($rawData->getStatusCode() === 200) {
  303.                             $rawData = $rawData->getContent();
  304.                             $data = \json_decode($rawData);
  305.                             if ($data) {
  306.                                 $data = $data->results;
  307.                                 foreach ($data as $publication) {
  308.                                     $pages=0;
  309.                                     $authorsz=[];
  310.                                     $publicationName = $publication->display_name;
  311.                                     $year=$publication->publication_year;
  312.                                     $type=$publication->type;
  313.                                     $volume=$publication->biblio->volume;
  314.                                     $authors=$publication->authorships;
  315.                                     $link=$publication->id;
  316.                                     if($publication->biblio->last_page && $publication->biblio->first_page)
  317.                                     {
  318.                                         $pages=intval($publication->biblio->last_page)-intval($publication->biblio->first_page);
  319.                                     }
  321.                                     foreach ($authors as $a){
  322.                                         if(isset($a->raw_author_name)){
  323.                                             $authorsz[]=$a->raw_author_name;
  324.                                             if(!in_array($a->raw_author_name,$selectedAuthors) && strtolower($auteur)!==strtolower($a->raw_author_name)){
  325.                                                 $selectedAuthors[]=$a->raw_author_name;
  326.                                             }
  327.                                         }
  328.                                     }
  329.                                     $publications[] = [
  330.                                         'title' => $publicationName,
  331.                                         'url' => $link,
  332.                                         'authors' => $authorsz,
  333.                                         'year' => $year,
  334.                                         'type' => $type,
  335.                                         'page' => $pages,
  336.                                         'volume' => $volume,
  337.                                         'subject' => [],
  338.                                         'journal' => "",
  339.                                         'reference_count' => 0];
  341.                                 }
  342.                                 //dd('end',$publications);
  343.                             }
  344.                         }
  345.                     }
  346.                 }
  347. //            }
  348.                usort($publications, function ($a, $b) {
  349.                    return (int) $b['year'] <=> (int) $a['year'];
  350.                });
  352.                $suggestedJournals = array_filter($suggestedJournals);
  353.             $selectedAuthors = array_values($selectedAuthors);
  355.             // remove empty values from array journals
  356.             $selectedAuthors = array_filter(array_map('trim', $selectedAuthors), function($value) {
  357.                 return $value !== "" && $value !== null;
  358.             });
  359.             // appliquer la fonction strtolower sur chaque élément du tableau
  360.             $selectedAuthors = array_map('strtolower', $selectedAuthors);
  361.             $selectedAuthors = array_map('trim', $selectedAuthors);
  362.             $selectedAuthors = array_unique($selectedAuthors);
  365.             if (($key = array_search(strtolower($auteur), $selectedAuthors)) !== false) {
  366.                 unset($selectedAuthors[$key]);
  367.             }
  368.             // 4 items from the array of selectedAuthors
  369.             $selectedAuthors = array_slice($selectedAuthors, 0, 4);
  370.             foreach ($selectedAuthors as $a) {
  371.                 // get gender of author
  372. //        $client = HttpClient::create();
  373. //        $response = $client->request('GET', 'https://api.genderize.io', [
  374. //            'query' => [
  375. //                'name' => $a
  376. //            ]
  377. //        ]);
  378. //        $statusCode = $response->getStatusCode();
  379. //        if ($statusCode === 200) {
  380. //            $content = $response->toArray();
  381. //            $gender = $content['gender'];
  382. //        }
  383.                 // get gender of author end
  384.                 $authorList[] = ['name' => $a, 'gender' => $gender];
  385.             }
  386.         }
  388.             else {
  389.                 $rawData = $worksData->getContent();
  390.                 if ($rawData->getStatusCode() === 200) {
  391.                     $data = \json_decode($rawData);
  392.                     $message = $data->message->items;
  393.                     foreach ($message as $item) {
  394.                         if (isset($item->title) && isset($item->type) && $item->type == "journal-article") {
  395.                             $article = $item->title[0];
  396.                             $url = $item->URL;
  397.                             $authors = $item->author;
  398.                             // get given and family name of authors
  399.                             foreach ($authors as $author) {
  400.                                 $given = '';
  401.                                 $family = '';
  402.                                 if (isset($author->family)) {
  403.                                     $family = $author->family;
  404.                                 }
  405.                                 if (isset($author->given)) {
  406.                                     $given = $author->given;
  407.                                 }
  408.                                 $fullName[] = $given . ' ' . $family;
  409.                             }
  411.                             $published = ((get_object_vars($item->published)));
  412.                             $year = $published['date-parts'][0];
  413.                             $year = $year[0];
  414.                             $title = "";
  415.                             $reference_count = 0;
  416.                             if (isset($item->{'container-title'}) && is_array($item->{'container-title'})) {
  417.                                 // Access the first element of the 'short-container-title' array
  418.                                 $title = $item->{'container-title'}[0];
  419.                             } elseif (isset($item->{'short-container-title'}) && is_array($item->{'short-container-title'})) {
  420.                                 // Access the first element of the 'container-title' array
  421.                                 $title = $item->{'short-container-title'}[0];
  422.                             }
  423.                             if (isset($item->{'reference-count'})) {
  424.                                 $reference_count = $item->{'reference-count'};
  425.                             }
  426.                             $page = $item->page ?? '';
  427.                             $volume = $item->volume ?? '';
  428.                             $subject = $item->subject ?? '';
  429.                             if ($subject) $subject = implode(',', $subject);
  430.                             if (in_array($given . ' ' . $family, $fullName)) {
  431.                                 $publications[] = ['title' => $article, 'url' => $url, 'authors' => $fullName, 'year' => $year, 'page' => $page, 'volume' => $volume, 'subject' => $subject, 'journal' => $title, 'reference_count' => $reference_count];
  432.                             }
  433.                             if (!in_array($title, $suggestedJournals)) {
  434.                                 $suggestedJournals[] = $this->entityManager->getRepository(Journal::class)->findOneBy(['title' => $title]);
  435.                             }
  436.                             if (!in_array($fullName, $selectedAuthors)) {
  437.                                 $selectedAuthors[] = $fullName;
  438.                             }
  440.                             $fullName = [];
  441.                         }
  442.                     }
  443.                 }
  444.             }
  447.     // check if the author exists in the database
  448.         $author_db=$this->entityManager->getRepository(Author::class)->findOneBy(['name'=>$auteur]);
  449.         if($author_db){
  450.             if($author_db->getLastKnownInstitutions() && count($author_db->getLastKnownInstitutions())>0){
  451.                 $institution=$author_db->getLastKnownInstitutions()[0]->display_name;
  452.                 $country=$author_db->getLastKnownInstitutions()[0]->country_code;
  453.             }
  454.             if($author_db->getTopics()){
  455.                foreach ($author_db->getTopics() as $topic){
  456.                    $topics[]=$topic['field']['display_name'];
  457.                }
  458.             }
  459.            $topics=array_unique($topics);
  460.             // get 10 items from the array of topics
  461.             $topics = array_slice($topics, 0, 6);
  462.         }
  464.         return $this->render('refonte/authors/publications-crossref.html.twig',
  465.             [
  466.                 'dataissn'=>$dd1,
  467.                 'auteur'=> $auteur,
  468.                 'authorDB'=>$authorDB,
  469.                 'co_authors'=> $co_authors,
  470.                 'exist'=> $exist,
  471.                 'countFollowers'=> $countFollowers,
  472.                 'author_db'=> $author_db,
  473.                 'search'=> $search,
  474.                 'manyRequests'=>$manyRequests,
  475.                 'publications'=>$publications,
  476.                 "followers"=>count($followers),
  477.                 "gender"=>$gender,
  478.                 "suggestedJournals"=>$suggestedJournals,
  479.                 "selectedAuthors"=>$authorList,
  480.                 "institution"=>$institution,
  481.                 "country"=>$country,
  482.                 "topics"=>$topics
  483.             ]);
  484.     }
  486.     /**
  487.      * sort by date data gived by dblp api
  488.      * @param $a
  489.      * @param $b
  490.      * @return mixed
  491.      */
  492.     public function sortdblp($a,$b){
  493.         $temp=[];
  494.         for($i=0;$i<$b;$i++){
  495.             for ($j=0;$j<$b;$j++){
  496.                 if ($a[$i]->info->year > $a[$j]->info->year)
  497.                 {
  498.                     $temp=$a[$i];
  499.                     $a[$i]=$a[$j];
  500.                     $a[$j]=$temp;
  501.                 }
  502.             }
  503.         }
  504.         return $a;
  506.     }
  508. }