BenGorFile\File\Domain\Model\File

Complexity

Total Complexity

14

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	id()	0	4	1
A	createdOn()	0	4	1
A	mimeType()	0	4	1
A	name()	0	4	1
A	overwrite()	0	8	1
A	remove()	0	4	1
A	rename()	0	11	2
A	updatedOn()	0	4	1
A	__toString()	0	4	1
A	availableMimeTypes()	0	4	1
A	setMimeType()	0	7	2

<?php

/*
 * This file is part of the BenGorFile package.
 *
 * (c) Beñat Espiña <benatespina@gmail.com>
 * (c) Gorka Laucirica <gorka.lauzirika@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace BenGorFile\File\Domain\Model;

/**
 * File domain class.
 *
 * @author Beñat Espiña <benatespina@gmail.com>
 * @author Gorka Laucirica <gorka.lauzirika@gmail.com>
 */
class File extends FileAggregateRoot
{
    /**
     * The id.
     *
     * @var FileId
     */
    protected $id;

    /**
     * Created on.
     *
     * @var \DateTimeImmutable
     */
    protected $createdOn;

    /**
     * The file mime type.
     *
     * @var FileMimeType
     */
    protected $mimeType;

    /**
     * The file name.
     *
     * @var FileName
     */
    protected $name;

    /**
     * Updated on.
     *
     * @var \DateTimeImmutable
     */
    protected $updatedOn;

    /**
     * Constructor.
     *
     * @param FileId       $anId      The id
     * @param FileName     $aName     The file name
     * @param FileMimeType $aMimeType The file mime type
     */
    public function __construct(FileId $anId, FileName $aName, FileMimeType $aMimeType)
    {
        $this->id = $anId;
        $this->name = $aName;
        $this->createdOn = new \DateTimeImmutable();
        $this->updatedOn = new \DateTimeImmutable();
        $this->setMimeType($aMimeType);

        $this->publish(new FileUploaded($this->id(), new FileName($aName)));
    }

    /**
     * Gets the id.
     *
     * @return FileId
     */
    public function id()
    {
        return $this->id;
    }

    /**
     * Gets the created on.
     *
     * @return \DateTimeImmutable
     */
    public function createdOn()
    {
        return $this->createdOn;
    }

    /**
     * Gets the file mime type.
     *
     * @return FileMimeType
     */
    public function mimeType()
    {
        return $this->mimeType;
    }

    /**
     * Gets the file name.
     *
     * @return FileName
     */
    public function name()
    {
        return $this->name;
    }

    /**
     * Overwrites the file.
     *
     * @param FileName     $aName     The file name
     * @param FileMimeType $aMimeType The file mime type
     */
    public function overwrite(FileName $aName, FileMimeType $aMimeType)
    {
        $this->name = $aName;
        $this->mimeType = $aMimeType;
        $this->updatedOn = new \DateTimeImmutable();

        $this->publish(new FileOverwritten($this->id()));
    }

    /**
     * Removes the file.
     */
    public function remove()
    {
        $this->publish(new FileRemoved($this->id()));
    }

    /**
     * Renames the file.
     *
     * @param FileName $aName The file name
     *
     * @throws FileNameInvalidException when the file name extension is different of the current
     */
    public function rename(FileName $aName)
    {
        if ($aName->extension() !== $this->name()->extension()) {
            throw new FileNameInvalidException();
        }

        $this->name = $aName;
        $this->updatedOn = new \DateTimeImmutable();

        $this->publish(new FileRenamed($this->id()));
    }

    /**
     * Gets the updated on.
     *
     * @return \DateTimeImmutable
     */
    public function updatedOn()
    {
        return $this->updatedOn;
    }

    /**
     * Magic method that represents the file domain object in string format.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->name->filename();
    }

    /**
     * Gets the available mime types in scalar type.
     *
     * This method is an extension point that it allows
     * to add more mime types easily in the domain.
     *
     * @return array
     */
    public static function availableMimeTypes()
    {
        return FileMimeType::mimeTypes();
    }

    /**
     * Sets the given mime type in the file scope.
     *
     * @param FileMimeType $aMimeType The mime type
     *
     * @throws FileMimeTypeDoesNotSupportException when the given mime type is not support for the file
     */
    private function setMimeType(FileMimeType $aMimeType)
    {
        if (!in_array($aMimeType->mimeType(), $this->availableMimeTypes(), true)) {
            throw new FileMimeTypeDoesNotSupportException();
        }
        $this->mimeType = $aMimeType;
    }
}