Cv\Entity\Cv

Complexity

Total Complexity

41

Size/Duplication

Total Lines	396
Duplicated Lines	0 %

Coupling/Cohesion

Components	9
Dependencies	9

Importance

Changes	11
Bugs	0	Features	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getUser()	0	4	1
A	setUser()	0	8	1
A	getResourceId()	0	4	1
A	getContact()	0	4	1
A	setContact()	0	8	2
A	getEducations()	0	7	2
A	getEducationsIndexedById()	0	4	1
A	setEducations()	0	5	1
A	getEmployments()	0	7	2
A	getEmploymentsIndexedById()	0	4	1
A	setEmployments()	0	5	1
A	getSkills()	0	7	2
A	getSkillsIndexedById()	0	4	1
A	setSkills()	0	5	1
A	setIsDraft()	0	5	1
A	isDraft()	0	4	1
A	getPreferredJob()	0	7	2
A	setPreferredJob()	0	5	1
A	getLanguageSkills()	0	7	2
A	setLanguageSkills()	0	5	1
A	getLanguageSkillsIndexedById()	0	4	1
A	setNativeLanguages()	0	5	1
A	getNativeLanguages()	0	4	1
A	getStatus()	0	4	1
A	setStatus()	0	10	2
A	setAttachments()	0	5	1
A	getAttachments()	0	7	2
A	setupPermissions()	0	6	2
A	updatePermissions()	0	14	3

<?php

namespace Cv\Entity;

use Auth\Entity\InfoInterface;
use Auth\Entity\UserInterface;
use Core\Collection\IdentityWrapper;
use Core\Entity\AbstractIdentifiableEntity;
use Core\Entity\DraftableEntityInterface;
use Core\Entity\ModificationDateAwareEntityTrait;
use Core\Entity\PermissionsAwareTrait;
use Core\Entity\PermissionsInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection as CollectionInterface;
use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
use Zend\Permissions\Acl\Resource\ResourceInterface;

/**
 * Defines CV Model
 *
 * @ODM\Document(collection="cvs", repositoryClass="\Cv\Repository\Cv")
 * @ODM\Indexes({
 *     @ODM\Index(keys={
 *          "preferredJob.desiredJob"="text"
 *     },name="cvFulltext")
 * })
 * @ODM\HasLifecycleCallbacks
 */
class Cv extends AbstractIdentifiableEntity implements CvInterface, ResourceInterface
{
    use PermissionsAwareTrait, ModificationDateAwareEntityTrait;

    /**
     * Owner of the CV
     *
     * @var UserInterface
     * @ODM\ReferenceOne(targetDocument="\Auth\Entity\User", simple=true, cascade="persist")
     */
    protected $user;
    
    /**
     * personal informations, contains firstname, lastname, email,
     * phone etc.
     *
     * @ODM\EmbedOne(targetDocument="Contact")
     */
    protected $contact;
    
    /**
     * Education History
     *
     * @var ArrayCollection
     * @ODM\EmbedMany(targetDocument="\Cv\Entity\Education")
     */
    protected $educations;
    
    /**
     * Employment History
     *
     * @var ArrayCollection
     * @ODM\EmbedMany(targetDocument="\Cv\Entity\Employment")
     */
    protected $employments;
    
    /**
     * Skills
     *
     * @var ArrayCollection
     * @ODM\EmbedMany(targetDocument="\Cv\Entity\Skill")
     */
    protected $skills;

    /**
    * Skills
    *
    * @var ArrayCollection
    * @ODM\EmbedMany(targetDocument="\Cv\Entity\Language")
    */
    protected $languageSkills;

    /**
     * @var array
     * @ODM\Collection
     */
    protected $nativeLanguages=[];


    /**
     * Preferred Job. Where do the user want to work? What kind of work he wants do do
     *
     * @ODM\EmbedOne(targetDocument="\Cv\Entity\PreferredJob")
     */
    protected $preferredJob;

    /**
     * Flag indicating draft state of this cv.
     *
     * @var bool
     * @ODM\Boolean
     */
    protected $isDraft = false;
    
    /**
     * Status
     *
     * @var Status
     * @ODM\EmbedOne(targetDocument="Status")
     * @ODM\Index
     */
    protected $status;
    
    /**
     * Multiple attachments
     *
     * @since 0.26
     * @ODM\ReferenceMany(targetDocument="Attachment", simple="true", cascade={"persist", "remove"})
     */
    protected $attachments;

    public function __construct()
    {
        $this->status = new Status();
    }
    
    /**
     * @return UserInterface
     */
    public function getUser()
    {
        return $this->user;
    }

    /**
     * @param UserInterface $user
     * @return $this
     */
    public function setUser(UserInterface $user)
    {
        $oldUser    = $this->user;
        $this->user = $user;
        $this->updatePermissions($oldUser);

        return $this;
    }

    /**
     * Returns the string identifier of the Resource
     *
     * @return string
     */
    public function getResourceId()
    {
        return 'Entity/Cv';
    }


    /**
     * @return Contact
     */
    public function getContact()
    {
        return $this->contact;
    }
    
    /**
     * @return Cv
     */
    public function setContact(InfoInterface $contact)
    {
        if (!$contact instanceof Contact) {
            $contact = new Contact($contact);
        }
        $this->contact = $contact;
        return $this;
    }
    
    /**
     * @return ArrayCollection
     */
    public function getEducations()
    {
        if (!$this->educations) {
            $this->setEducations(new ArrayCollection());
        }
        return $this->educations;
    }
    
    /**
     * @return ArrayCollection

Should the return type not be IdentityWrapper?

     */
    public function getEducationsIndexedById()
    {
        return new IdentityWrapper($this->getEducations());
    }

    /**
     * @param CollectionInterface $educations
     * @return $this
     */
    public function setEducations(CollectionInterface $educations)
    {
        $this->educations = $educations;

$educations is of type object<Doctrine\Common\Collections\Collection>, but the property $educations was declared to be of type object<Doctrine\Common\Collections\ArrayCollection>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        return $this;
    }

    /**
     * @return ArrayCollection
     */
    public function getEmployments()
    {
        if (!$this->employments) {
            $this->setEmployments(new ArrayCollection());
        }
        return $this->employments;
    }
    
    /**
     * @return ArrayCollection

Should the return type not be IdentityWrapper?

     */
    public function getEmploymentsIndexedById()
    {
        return new IdentityWrapper($this->getEmployments());
    }

    /**
     * @param CollectionInterface $employments
     * @return $this
     */
    public function setEmployments(CollectionInterface $employments)
    {
        $this->employments = $employments;

$employments is of type object<Doctrine\Common\Collections\Collection>, but the property $employments was declared to be of type object<Doctrine\Common\Collections\ArrayCollection>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        return $this;
    }
    
    /**
     * @return ArrayCollection
     */
    public function getSkills()
    {
        if (!$this->skills) {
            $this->setSkills(new ArrayCollection());
        }
        return $this->skills;
    }
    
    /**
     * @return ArrayCollection

Should the return type not be IdentityWrapper?

     */
    public function getSkillsIndexedById()
    {
        return new IdentityWrapper($this->getSkills());
    }

    /**
     * @param CollectionInterface $skills
     * @return $this
     */
    public function setSkills(CollectionInterface $skills)
    {
        $this->skills = $skills;

$skills is of type object<Doctrine\Common\Collections\Collection>, but the property $skills was declared to be of type object<Doctrine\Common\Collections\ArrayCollection>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        return $this;
    }

    /**
     * @param bool $isDraft
     * @return $this
     */
    public function setIsDraft($isDraft)
    {
        $this->isDraft=$isDraft;
        return $this;
    }

    /**
     * @return boolean
     */
    public function isDraft()
    {
        return $this->isDraft;
    }

    /**
     * @return \Cv\Entity\PreferredJobInterface
     */
    public function getPreferredJob()
    {
        if (null == $this->preferredJob) {
            $this->preferredJob = new PreferredJob();
        }
        return $this->preferredJob;
    }

    /**
     * @param \Cv\Entity\PreferredJobInterface $preferredJob
     * @return $this
     */
    public function setPreferredJob(PreferredJobInterface $preferredJob)
    {
        $this->preferredJob = $preferredJob;
        return $this;
    }

    /**
     * @return ArrayCollection
     */
    public function getLanguageSkills()
    {
        if (!$this->languageSkills) {
            $this->setLanguageSkills(new ArrayCollection());
        }
        return $this->languageSkills;
    }

    /**
     * @param CollectionInterface $languageSkills
     * @return $this
     */
    public function setLanguageSkills(CollectionInterface $languageSkills)
    {
        $this->languageSkills = $languageSkills;

$languageSkills is of type object<Doctrine\Common\Collections\Collection>, but the property $languageSkills was declared to be of type object<Doctrine\Common\Collections\ArrayCollection>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        return $this;
    }

    /**
     * @return ArrayCollection

Should the return type not be IdentityWrapper?

     */
    public function getLanguageSkillsIndexedById()
    {
        return new IdentityWrapper($this->getLanguageSkills());
    }

    /**
     * Sets the mothers tongue of the candidate
     *
     * @param array
     * @return $this
     */
    public function setNativeLanguages($nativeLanguages)
    {
        $this->nativeLanguages=$nativeLanguages;
        return $this;
    }

    /**
     * Gets the mothers tongue of the candidate
     *
     * @return string

Should the return type not be array?

     */
    public function getNativeLanguages()
    {
        return $this->nativeLanguages;
    }
    
    /**
     * @return Status
     */
    public function getStatus()
    {
        return $this->status;
    }
    
    /**
     * @param Status|string $status
     */
    public function setStatus($status)
    {
        if (!$status instanceof Status) {
            $status = new Status($status);
        }
    
        $this->status = $status;

        return $this;
    }

    /**
     * @param CollectionInterface $attachments
     * @return Cv
     * @since 0.26
     */
    public function setAttachments(CollectionInterface $attachments)
    {
        $this->attachments = $attachments;
        return $this;
    }

    /**
     * @return CollectionInterface
     * @since 0.26
     */
    public function getAttachments()
    {
        if (!$this->attachments) {
            $this->setAttachments(new ArrayCollection());
        }
        return $this->attachments;
    }

    /**
     *
     * @param PermissionsInterface $permissions

Should the type for parameter $permissions not be null|PermissionsInterface?

     */
    private function setupPermissions(PermissionsInterface $permissions = null)
    {
        if ($this->user) {
            $permissions->grant($this->user, PermissionsInterface::PERMISSION_ALL);

It seems like $permissions is not always an object, but can also be of type null. Maybe add an additional type check?

        }
    }

    private function updatePermissions($oldUser = null)
    {
        $hasPermissions = (bool) $this->permissions;
        $permissions = $this->getPermissions();

        if ($hasPermissions) {
            $oldUser && $permissions->revoke($oldUser, PermissionsInterface::PERMISSION_ALL);
            $this->setupPermissions($permissions);
        }

        /*
         * getPermissions() already granted the user we need not to do anything.
         */
    }
}