src/Entity/Publication.php line 13

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\PublicationRepository;
  4. use Doctrine\Common\Collections\Collection;
  5. use Doctrine\ORM\Mapping as ORM;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. /**
  8.  * @ORM\Entity(repositoryClass=PublicationRepository::class)
  9.  */
  10. class Publication
  11. {
  12.     /**
  13.      * @ORM\Id
  14.      * @ORM\GeneratedValue
  15.      * @ORM\Column(type="integer")
  16.      */
  17.     private $id;
  18.     /**
  19.      * @ORM\Column(type="string", length=255)
  20.      */
  21.     private $title;
  22.     /**
  23.      * @ORM\Column(type="string", length=255)
  24.      */
  25.     private $UT;
  26.     /**
  27.      * @ORM\Column(type="string", length=50)
  28.      */
  29.     private $doctype;
  30.     /**
  31.      * @ORM\Column(type="string", length=30, nullable=true)
  32.      */
  33.     private $pages;
  34.     /**
  35.      * @ORM\Column(type="string", length=50, nullable=true)
  36.      */
  37.     private $ISSUE;
  38.     /**
  39.      * @ORM\Column(type="string", length=30, nullable=true)
  40.      */
  41.     private $volume;
  42.     /**
  43.      * @ORM\Column(type="string", length=10, nullable=true)
  44.      */
  45.     private $publishedMonth;
  46.     /**
  47.      * @ORM\Column(type="integer", nullable=true)
  48.      */
  49.     private $publishedYear;
  50.     /**
  51.      * @ORM\Column(type="string", length=255, nullable=true)
  52.      */
  53.     private $doi;
  54.     /**
  55.      * @ORM\Column(type="string", length=255, nullable=true)
  56.      */
  57.     private $ISSN;
  58.     /**
  59.      * @ORM\Column(type="string", length=255, nullable=true)
  60.      */
  61.     private $ISBN;
  62.     /**
  63.      * Many Publications have Many Keywords.
  64.      * @ORM\ManyToMany(targetEntity="Keyword", inversedBy="publications")
  65.      * @ORM\JoinTable(name="publications_keywords")
  66.      */
  67.     private $keywords;
  68.     /**
  69.      * Many Publications have Many KeywordsPlus.
  70.      * @ORM\ManyToMany(targetEntity="KeywordPlus", inversedBy="publications")
  71.      * @ORM\JoinTable(name="publications_keywordsPlus")
  72.      */
  73.     private $keywordsPlus;
  74.     /**
  75.      * One publication has many wosRecords. This is the inverse side.
  76.      * @ORM\OneToMany(targetEntity="WosRecord", mappedBy="publication")
  77.      */
  78.     private $wosRecords;
  79.     /**
  80.      * One publication has many Grants. This is the inverse side.
  81.      * @ORM\OneToMany(targetEntity="Grant", mappedBy="publication")
  82.      */
  83.     private $grants;
  84.     /**
  85.      * One publication has many PublicationAuthors. This is the inverse side.
  86.      * @ORM\OneToMany(targetEntity="PublicationAuthor", mappedBy="publication")
  87.      */
  88.     private $publicationAuthors;
  89.    
  90.     /**
  91.      * @ORM\Column(type="date")
  92.      */
  93.     private $updatedDate;
  94.     /**
  95.      * @ORM\Column(type="text", nullable=true)
  96.      */
  97.     private $abstract;
  98.     /**
  99.      * @ORM\Column(type="integer", nullable=true)
  100.      */
  101.     private $timesCited;
  102.     /**
  103.      * @ORM\Column(type="text", nullable=true)
  104.      */
  105.     private $fundingText;
  106.     /**
  107.      * Many Publications have one Journal. This is the owning side.
  108.      * @ORM\ManyToOne(targetEntity="Journal", inversedBy="publications", cascade={"persist"})
  109.      * @ORM\JoinColumn(name="journal_id", referencedColumnName="id")
  110.      */
  111.     private $journal;
  112.     /**
  113.      * @ORM\Column(type="boolean", nullable=true)
  114.      */
  115.     private $interdisciplinary;
  116.     /**
  117.      * @ORM\Column(type="boolean", nullable=true)
  118.      */
  119.     private $validated;
  120.     /**
  121.      * @ORM\Column(type="integer", nullable=true)
  122.      */
  123.     private $sidingId;
  124.     /**
  125.      * @ORM\ManyToOne(targetEntity=Publisher::class, inversedBy="publications")
  126.      */
  127.     private $publisher;
  128.     /**
  129.      * @ORM\Column(type="string", length=255, nullable=true)
  130.      */
  131.     private $publicComments;
  132.     /**
  133.      * @ORM\Column(type="string", length=255, nullable=true)
  134.      */
  135.     private $privateComments;
  136.     /**
  137.      * @ORM\Column(type="string", length=50)
  138.      */
  139.     private $publicationType 'paper'//para saber si son publicaciones tipo paper, conferencias o conferencia a*
  140.     public function __construct() {
  141.         $this->validated false;
  142.         $this->keywords = new ArrayCollection();
  143.         $this->wosRecords = new ArrayCollection();
  144.         $this->grants = new ArrayCollection();
  145.         $this->publicationAuthors = new ArrayCollection();
  146.         $this->keywordsPlus = new ArrayCollection();
  147.     }
  148.     public function getId(): ?int
  149.     {
  150.         return $this->id;
  151.     }
  152.     public function getTitle(): ?string
  153.     {
  154.         return $this->title;
  155.     }
  156.     public function setTitle(string $title): self
  157.     {
  158.         $this->title $title;
  159.         return $this;
  160.     }
  161.     public function getUT(): ?string
  162.     {
  163.         return $this->UT;
  164.     }
  165.     public function setUT(string $UT): self
  166.     {
  167.         $this->UT $UT;
  168.         return $this;
  169.     }
  170.     public function getDoctype(): ?string
  171.     {
  172.         return $this->doctype;
  173.     }
  174.     public function setDoctype(string $doctype): self
  175.     {
  176.         $this->doctype $doctype;
  177.         return $this;
  178.     }
  179.     public function getPages(): ?string
  180.     {
  181.         return $this->pages;
  182.     }
  183.     public function setPages(?string $pages): self
  184.     {
  185.         $this->pages $pages;
  186.         return $this;
  187.     }
  188.     public function getISSUE(): ?string
  189.     {
  190.         return $this->ISSUE;
  191.     }
  192.     public function setISSUE(?string $ISSUE): self
  193.     {
  194.         $this->ISSUE $ISSUE;
  195.         return $this;
  196.     }
  197.     public function getVolume(): ?string
  198.     {
  199.         return $this->volume;
  200.     }
  201.     public function setVolume(?string $volume): self
  202.     {
  203.         $this->volume $volume;
  204.         return $this;
  205.     }
  206.     public function getPublishedMonth(): ?string
  207.     {
  208.         return $this->publishedMonth;
  209.     }
  210.     public function setPublishedMonth(?string $publishedMonth): self
  211.     {
  212.         $this->publishedMonth $publishedMonth;
  213.         return $this;
  214.     }
  215.     public function getPublishedYear(): ?int
  216.     {
  217.         return $this->publishedYear;
  218.     }
  219.     public function setPublishedYear(?int $publishedYear): self
  220.     {
  221.         $this->publishedYear $publishedYear;
  222.         return $this;
  223.     }
  224.     /**
  225.      * @return Collection<int, Keyword>
  226.      */
  227.     public function getKeywords(): Collection
  228.     {
  229.         return $this->keywords;
  230.     }
  231.     public function addKeyword(Keyword $keyword): self
  232.     {
  233.         if (!$this->keywords->contains($keyword)) {
  234.             $this->keywords[] = $keyword;
  235.         }
  236.         return $this;
  237.     }
  238.     public function removeKeyword(Keyword $keyword): self
  239.     {
  240.         $this->keywords->removeElement($keyword);
  241.         return $this;
  242.     }
  243.     public function getUpdatedDate(): ?\DateTimeInterface
  244.     {
  245.         return $this->updatedDate;
  246.     }
  247.     public function setUpdatedDate(\DateTimeInterface $updatedDate): self
  248.     {
  249.         $this->updatedDate $updatedDate;
  250.         return $this;
  251.     }
  252.     public function getDoi(): ?string
  253.     {
  254.         return $this->doi;
  255.     }
  256.     public function setDoi(?string $doi): self
  257.     {
  258.         $this->doi $doi;
  259.         return $this;
  260.     }
  261.     /**
  262.      * @return Collection<int, WosRecord>
  263.      */
  264.     public function getWosRecords(): Collection
  265.     {
  266.         return $this->wosRecords;
  267.     }
  268.     public function addWosRecord(WosRecord $wosRecord): self
  269.     {
  270.         if (!$this->wosRecords->contains($wosRecord)) {
  271.             $this->wosRecords[] = $wosRecord;
  272.             $wosRecord->setPublication($this);
  273.         }
  274.         return $this;
  275.     }
  276.     public function removeWosRecord(WosRecord $wosRecord): self
  277.     {
  278.         if ($this->wosRecords->removeElement($wosRecord)) {
  279.             // set the owning side to null (unless already changed)
  280.             if ($wosRecord->getPublication() === $this) {
  281.                 $wosRecord->setPublication(null);
  282.             }
  283.         }
  284.         return $this;
  285.     }
  286.     public function getAbstract(): ?string
  287.     {
  288.         return $this->abstract;
  289.     }
  290.     public function setAbstract(?string $abstract): self
  291.     {
  292.         $this->abstract $abstract;
  293.         return $this;
  294.     }
  295.     public function getTimesCited(): ?int
  296.     {
  297.         return $this->timesCited;
  298.     }
  299.     public function setTimesCited(?int $timesCited): self
  300.     {
  301.         $this->timesCited $timesCited;
  302.         return $this;
  303.     }
  304.     /**
  305.      * @return Collection<int, Grant>
  306.      */
  307.     public function getGrants(): Collection
  308.     {
  309.         return $this->grants;
  310.     }
  311.     public function addGrant(Grant $grant): self
  312.     {
  313.         if (!$this->grants->contains($grant)) {
  314.             $this->grants[] = $grant;
  315.             $grant->setPublication($this);
  316.         }
  317.         return $this;
  318.     }
  319.     public function removeGrant(Grant $grant): self
  320.     {
  321.         if ($this->grants->removeElement($grant)) {
  322.             // set the owning side to null (unless already changed)
  323.             if ($grant->getPublication() === $this) {
  324.                 $grant->setPublication(null);
  325.             }
  326.         }
  327.         return $this;
  328.     }
  329.     /**
  330.      * @return Collection<int, PublicationAuthor>
  331.      */
  332.     public function getPublicationAuthors(): Collection
  333.     {
  334.         return $this->publicationAuthors;
  335.     }
  336.     public function addPublicationAuthor(PublicationAuthor $publicationAuthor): self
  337.     {
  338.         if (!$this->publicationAuthors->contains($publicationAuthor)) {
  339.             $this->publicationAuthors[] = $publicationAuthor;
  340.             $publicationAuthor->setPublication($this);
  341.         }
  342.         return $this;
  343.     }
  344.     public function removePublicationAuthor(PublicationAuthor $publicationAuthor): self
  345.     {
  346.         if ($this->publicationAuthors->removeElement($publicationAuthor)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($publicationAuthor->getPublication() === $this) {
  349.                 $publicationAuthor->setPublication(null);
  350.             }
  351.         }
  352.         return $this;
  353.     }
  354.     /**
  355.      * @return Collection<int, KeywordPlus>
  356.      */
  357.     public function getKeywordsPlus(): Collection
  358.     {
  359.         return $this->keywordsPlus;
  360.     }
  361.     public function addKeywordsPlu(KeywordPlus $keywordsPlu): self
  362.     {
  363.         if (!$this->keywordsPlus->contains($keywordsPlu)) {
  364.             $this->keywordsPlus[] = $keywordsPlu;
  365.         }
  366.         return $this;
  367.     }
  368.     public function removeKeywordsPlu(KeywordPlus $keywordsPlu): self
  369.     {
  370.         $this->keywordsPlus->removeElement($keywordsPlu);
  371.         return $this;
  372.     }
  373.     public function getFundingText(): ?string
  374.     {
  375.         return $this->fundingText;
  376.     }
  377.     public function setFundingText(?string $fundingText): self
  378.     {
  379.         $this->fundingText $fundingText;
  380.         return $this;
  381.     }
  382.     
  383.     public function getIngAuthors() {
  384.         $ingAuthors = new ArrayCollection();
  385.         foreach ($this->publicationAuthors as $publicationAuthor) {
  386.             if(!is_null($publicationAuthor->getAuthor())) {
  387.                 $ingAuthors->add($publicationAuthor->getAuthor());
  388.             }
  389.         }
  390.         return $ingAuthors;
  391.     }
  392.     public function getIngPublicationAuthors() {
  393.         $ingPublicationAuthors = new ArrayCollection();
  394.         foreach ($this->publicationAuthors as $publicationAuthor) {
  395.             if(!is_null($publicationAuthor->getAuthor())) {
  396.                 $ingPublicationAuthors->add($publicationAuthor);
  397.             }
  398.         }
  399.         return $ingPublicationAuthors;
  400.     }
  401.     public function getExternalAuthors() {
  402.         $externalAuthors = new ArrayCollection();
  403.         foreach ($this->publicationAuthors as $publicationAuthor) {
  404.             if(!is_null($publicationAuthor->getExternalAuthor())) {
  405.                 $externalAuthors->add($publicationAuthor->getExternalAuthor());
  406.             }
  407.         }
  408.         
  409.         return $externalAuthors;
  410.     }
  411.     public function getISSN(): ?string
  412.     {
  413.         return $this->ISSN;
  414.     }
  415.     public function setISSN(?string $ISSN): self
  416.     {
  417.         $this->ISSN $ISSN;
  418.         return $this;
  419.     }
  420.     public function getISBN(): ?string
  421.     {
  422.         return $this->ISBN;
  423.     }
  424.     public function setISBN(?string $ISBN): self
  425.     {
  426.         $this->ISBN $ISBN;
  427.         return $this;
  428.     }
  429.     public function getJournal(): ?Journal
  430.     {
  431.         return $this->journal;
  432.     }
  433.     public function setJournal(?Journal $journal): self
  434.     {
  435.         $this->journal $journal;
  436.         return $this;
  437.     }
  438.     public function getInterdisciplinary(): ?bool
  439.     {
  440.         return $this->interdisciplinary;
  441.     }
  442.     public function setInterdisciplinary(?bool $interdisciplinary): self
  443.     {
  444.         $this->interdisciplinary $interdisciplinary;
  445.         return $this;
  446.     }
  447.     public function getValidated(): ?bool
  448.     {
  449.         return $this->validated;
  450.     }
  451.     public function setValidated(bool $validated):self
  452.     {
  453.         $this->validated $validated;
  454.         return $this;
  455.     }
  456.     public function getSidingId(): ?int
  457.     {
  458.         return $this->sidingId;
  459.     }
  460.     public function setSidingId(?int $sidingId): self
  461.     {
  462.         $this->sidingId $sidingId;
  463.         return $this;
  464.     }
  465.     public function getPublisher(): ?Publisher
  466.     {
  467.         return $this->publisher;
  468.     }
  469.     public function setPublisher(?Publisher $publisher): self
  470.     {
  471.         $this->publisher $publisher;
  472.         return $this;
  473.     }
  474.     public function getAuthorsCite() {
  475.         $authors = [];
  476.         foreach ($this->publicationAuthors as $author) {
  477.             $authors[] = $this->remove_accents($author->getCiteName());
  478.         }
  479.         return implode(', '$authors);
  480.     }
  481.     public function withFacultyUC() {
  482.         $with false;
  483.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  484.             if($publicationAuthor->getUcNotIng()) {
  485.                 $with true;
  486.                 break;
  487.             }
  488.         }
  489.         return $with;
  490.     }
  491.     public function withNational() {
  492.         $with false;
  493.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  494.             if( !$publicationAuthor->isIng()) {
  495.                 foreach ($publicationAuthor->getOrganizations() as $organization) {
  496.                     if( $organization->getCountry() == 'Chile') {
  497.                         $with true;
  498.                         break;
  499.                     }
  500.                 }
  501.                 if($with) break; //esto para evitar seguir con el loop
  502.             }
  503.         }
  504.         return $with;
  505.     }
  506.     public function withInternational() {
  507.         $with false;
  508.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  509.             if( !$publicationAuthor->isIng()) {
  510.                 foreach ($publicationAuthor->getOrganizations() as $organization) {
  511.                     if( $organization->getCountry() != 'Chile') {
  512.                         $with true;
  513.                         break;
  514.                     }
  515.                 }
  516.                 if($with) break; //esto para evitar seguir con el loop
  517.             }
  518.         }
  519.         return $with;
  520.     }
  521.     public function withTop50() {
  522.         $with false;
  523.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  524.             $organizations $publicationAuthor->getOrganizations();
  525.             //revisamos si organization tiene top50
  526.             foreach ($organizations as $organization) {
  527.                 if( count($organization->getTop50s()) > 0) {
  528.                     foreach ($organization->getTop50s() as $top50) {
  529.                         if( $top50->getYear() == $this->getPublishedYear() ) {
  530.                             $with true;
  531.                             break;
  532.                         }
  533.                     }
  534.                     if($with) break; //esto para evitar seguir con el loop
  535.                 }
  536.             }
  537.         }
  538.         return $with;
  539.     }
  540.     public function hasPDHStudent() {
  541.         $with false;
  542.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  543.             if( $publicationAuthor->getPhdStudent()) {
  544.                 $with true;
  545.                 break;
  546.             }
  547.         }
  548.         return $with;
  549.     }
  550.     public function hasMasterStudent() {
  551.         $with false;
  552.         foreach ($this->getPublicationAuthors() as $publicationAuthor) {
  553.             if( $publicationAuthor->getMasterStudent()) {
  554.                 $with true;
  555.                 break;
  556.             }
  557.         }
  558.         return $with;
  559.     }
  560.     public function remove_accents($string) {
  561.         return iconv('UTF-8''ASCII//TRANSLIT//IGNORE'$string);
  562.     }
  563.     public function getPublicComments(): ?string
  564.     {
  565.         return $this->publicComments;
  566.     }
  567.     public function setPublicComments(?string $publicComments): self
  568.     {
  569.         $this->publicComments $publicComments;
  570.         return $this;
  571.     }
  572.     public function getPrivateComments(): ?string
  573.     {
  574.         return $this->privateComments;
  575.     }
  576.     public function setPrivateComments(?string $privateComments): self
  577.     {
  578.         $this->privateComments $privateComments;
  579.         return $this;
  580.     }
  581.     public function getPublicationType(): ?string
  582.     {
  583.         return $this->publicationType;
  584.     }
  585.     public function getPublicationTypeChoices(): array
  586.     {
  587.         return [
  588.             'paper' => 'paper',
  589.             'conference' => 'conference',
  590.             'conference_a*' => 'conference_a*',
  591.         ];
  592.     }
  593.     public function setPublicationType(string $publicationType): self
  594.     {
  595.         // validar que el valor sea uno de los permitidos
  596.         if (!in_array($publicationType$this->getPublicationTypeChoices())) {
  597.             throw new \InvalidArgumentException('Invalid publication type');
  598.         }
  599.         $this->publicationType $publicationType;
  600.         return $this;
  601.     }
  602. }