Tinyissue\Form\Issue

Complexity

Total Complexity

43

Size/Duplication

Total Lines	422
Duplicated Lines	2.84 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

96%

Importance

Changes	14
Bugs	3	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getTags()	12	12	3
A	getIssueTag()	0	13	3
A	setup()	0	7	2
A	actions()	0	18	4
A	issueModifyFields()	0	22	1
A	fieldTitle()	0	9	1
A	fieldBody()	0	9	1
B	fieldStatusTags()	0	29	4
B	fieldTypeTags()	0	29	4
B	fieldResolutionTags()	0	36	4
A	fieldAssignedTo()	0	11	1
A	fieldUpload()	0	8	2
A	fields()	0	20	3
A	fieldTimeQuote()	0	53	3
A	rules()	0	9	1
A	getRedirectUrl()	0	8	2
A	extractQuoteValue()	0	15	4

<?php

/*
 * This file is part of the Tinyissue package.
 *
 * (c) Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tinyissue\Form;

use Tinyissue\Model;

/**
 * Issue is a class to defines fields & rules for add/edit issue form.
 *
 * @author Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 */
class Issue extends FormAbstract
{
    /**
     * An instance of project model.
     *
     * @var Model\Project
     */
    protected $project;

    /**
     * Collection of all tags.
     *
     * @var \Illuminate\Database\Eloquent\Collection
     */
    protected $tags = null;

    /**
     * @param string $type
     *
     * @return \Illuminate\Database\Eloquent\Collection|null
     */
    protected function getTags($type = null)

This method seems to be duplicated in your project.

    {
        if ($this->tags === null) {
            $this->tags = (new Model\Tag())->getGroupTags();
        }

        if ($type) {

The expression $type of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return $this->tags->where('name', $type)->first()->tags;
        }

        return $this->tags;
    }

    /**
     * Get issue tag for specific type/group.
     *
     * @param string $type
     *
     * @return int
     */
    protected function getIssueTag($type)
    {
        if ($this->isEditing()) {
            $groupId     = $this->getTags($type)->first()->parent_id;
            $selectedTag = $this->getModel()->tags->where('parent_id', $groupId);

            if ($selectedTag->count() > 0) {
                return $selectedTag->last();
            }
        }

        return new Model\Tag();

The return type of return new \Tinyissue\Model\Tag(); (Tinyissue\Model\Tag) is incompatible with the return type documented by Tinyissue\Form\Issue::getIssueTag of type integer.

    }

    /**
     * @param array $params
     *
     * @return void
     */
    public function setup(array $params)
    {
        $this->project = $params['project'];
        if (!empty($params['issue'])) {
            $this->editingModel($params['issue']);
        }
    }

    /**
     * @return array
     */
    public function actions()
    {
        $actions = [
            'submit' => $this->isEditing() ? 'update_issue' : 'create_issue',
        ];

        if ($this->isEditing() && auth()->user(Model\Permission::PERM_ISSUE_MODIFY)) {

The call to Guard::user() has too many arguments starting with \Tinyissue\Model\Permission::PERM_ISSUE_MODIFY.

            $actions['delete'] = [
                'type'         => 'danger_submit',
                'label'        => trans('tinyissue.delete_something', ['name' => '#' . $this->getModel()->id]),
                'class'        => 'close-issue',
                'name'         => 'delete-issue',
                'data-message' => trans('tinyissue.delete_issue_confirm'),
            ];
        }

        return $actions;
    }

    /**
     * @return array
     */
    public function fields()
    {
        $issueModify = \Auth::user()->permission('issue-modify');

        $fields = $this->fieldTitle();
        $fields += $this->fieldBody();
        $fields += $this->fieldTypeTags();

        // Only on creating new issue
        if (!$this->isEditing()) {
            $fields += $this->fieldUpload();
        }

        // Show fields for users with issue modify permission
        if ($issueModify) {
            $fields += $this->issueModifyFields();
        }

        return $fields;
    }

    /**
     * Return a list of fields for users with issue modify permission.
     *
     * @return array
     */
    protected function issueModifyFields()
    {
        $fields = [];

        $fields['internal_status'] = [
            'type' => 'legend',
        ];

        // Status tags
        $fields += $this->fieldStatusTags();

        // Assign users
        $fields += $this->fieldAssignedTo();

        // Quotes
        $fields += $this->fieldTimeQuote();

        // Resolution tags
        $fields += $this->fieldResolutionTags();

        return $fields;
    }

    /**
     * Returns title field.
     *
     * @return array
     */
    protected function fieldTitle()
    {
        return [
            'title' => [
                'type'  => 'text',
                'label' => 'title',
            ],
        ];
    }

    /**
     * Returns body field.
     *
     * @return array
     */
    protected function fieldBody()
    {
        return [
            'body' => [
                'type'  => 'textarea',
                'label' => 'issue',
            ],
        ];
    }

    /**
     * Returns status tag field.
     *
     * @return array
     */
    protected function fieldStatusTags()
    {
        $currentTag = $this->getIssueTag('status');

        if ($currentTag && !$currentTag->canView()) {

The method canView cannot be called on $currentTag (of type integer).

            $tags = [$currentTag];
        } else {
            $tags = $this->getTags('status');
        }

        $options = [];
        foreach ($tags as $tag) {

The expression $tags of type object<Illuminate\Database\Eloquent\Collection>|null|array<integer,integer,{"0":"integer"}> is not guaranteed to be traversable. How about adding an additional type check?

            $options[ucwords($tag->name)] = [
                'name'      => 'tag_status',
                'value'     => $tag->id,
                'data-tags' => $tag->id,
                'color'     => $tag->bgcolor,
            ];
        }

        $fields['tag_status'] = [

$fields was never initialized. Although not strictly required by PHP, it is generally a good practice to add $fields = array(); before regardless.

            'label'  => 'status',
            'type'   => 'radioButton',
            'radios' => $options,
            'check'  => $this->getIssueTag('status')->id,
        ];

        return $fields;
    }

    /**
     * Returns tags field.
     *
     * @return array
     */
    protected function fieldTypeTags()
    {
        $currentTag = $this->getIssueTag('type');

        if ($currentTag && !$currentTag->canView()) {

The method canView cannot be called on $currentTag (of type integer).

            $tags = [$currentTag];
        } else {
            $tags = $this->getTags('type');
        }

        $options = [];
        foreach ($tags as $tag) {

The expression $tags of type object<Illuminate\Database\Eloquent\Collection>|null|array<integer,integer,{"0":"integer"}> is not guaranteed to be traversable. How about adding an additional type check?

            $options[ucwords($tag->name)] = [
                'name'      => 'tag_type',
                'value'     => $tag->id,
                'data-tags' => $tag->id,
                'color'     => $tag->bgcolor,
            ];
        }

        $fields['tag_type'] = [

$fields was never initialized. Although not strictly required by PHP, it is generally a good practice to add $fields = array(); before regardless.

            'label'  => 'type',
            'type'   => 'radioButton',
            'radios' => $options,
            'check'  => $this->getIssueTag('type')->id,
        ];

        return $fields;
    }

    /**
     * Returns tags field.
     *
     * @return array
     */
    protected function fieldResolutionTags()
    {
        $currentTag = $this->getIssueTag('resolution');

        if ($currentTag && !$currentTag->canView()) {

The method canView cannot be called on $currentTag (of type integer).

            $tags = [$currentTag];
        } else {
            $tags = $this->getTags('resolution');
        }

        $options = [
            trans('tinyissue.none') => [
                'name'      => 'tag_resolution',
                'value'     => 0,
                'data-tags' => 0,
                'color'     => '#62CFFC',
            ],
        ];
        foreach ($tags as $tag) {

The expression $tags of type object<Illuminate\Database\Eloquent\Collection>|null|array<integer,integer,{"0":"integer"}> is not guaranteed to be traversable. How about adding an additional type check?

            $options[ucwords($tag->name)] = [
                'name'      => 'tag_resolution',
                'value'     => $tag->id,
                'data-tags' => $tag->id,
                'color'     => $tag->bgcolor,
            ];
        }

        $fields['tag_resolution'] = [

$fields was never initialized. Although not strictly required by PHP, it is generally a good practice to add $fields = array(); before regardless.

            'label'  => 'resolution',
            'type'   => 'radioButton',
            'radios' => $options,
            'check'  => $this->getIssueTag('resolution')->id,
        ];

        return $fields;
    }

    /**
     * Returns assigned to field.
     *
     * @return array
     */
    protected function fieldAssignedTo()
    {
        return [
            'assigned_to' => [
                'type'    => 'select',
                'label'   => 'assigned_to',
                'options' => [0 => ''] + $this->project->usersCanFixIssue()->get()->lists('fullname', 'id')->all(),
                'value'   => (int) $this->project->default_assignee,
            ],
        ];
    }

    /**
     * Returns upload field.
     *
     * @return array
     */
    protected function fieldUpload()
    {
        $user                      = \Auth::guest() ? new Model\User() : \Auth::user();
        $fields                    = $this->projectUploadFields('upload', $this->project, $user);
        $fields['upload']['label'] = 'attachments';

        return $fields;
    }

    /**
     * Returns time quote field.
     *
     * @return array
     */
    protected function fieldTimeQuote()
    {
        $fields = [
            'time_quote' => [
                'type'     => 'groupField',
                'label'    => 'quote',
                'fields'   => [
                    'h'    => [
                        'type'          => 'number',
                        'append'        => trans('tinyissue.hours'),
                        'value'         => $this->extractQuoteValue('h'),
                        'addGroupClass' => 'col-sm-5 col-md-5 col-lg-4',
                    ],
                    'm'    => [
                        'type'          => 'number',
                        'append'        => trans('tinyissue.minutes'),
                        'value'         => $this->extractQuoteValue('m'),
                        'addGroupClass' => 'col-sm-5 col-md-5 col-lg-4',
                    ],
                    'lock' => [
                        'type'          => 'checkboxButton',
                        'label'         => '',
                        'noLabel'       => 1,
                        'class'         => 'eee',
                        'value'         => $this->extractQuoteValue('lock'),
                        'addGroupClass' => 'sss col-sm-12 col-md-12 col-lg-4',
                        'checkboxes'    => [
                            'Lock Quote' => [
                                'value'     => 1,
                                'data-tags' => 1,
                                'color'     => 'red',
                                'checked'   => false,
                            ],
                        ],
                        'grouped'       => true,
                    ],
                ],
                'addClass' => 'row issue-quote',
            ],
        ];

        // If user does not have access to lock quote, then remove the field
        if (!auth()->user()->permission(Model\Permission::PERM_ISSUE_VIEW_QUOTE)) {

It seems like you code against a concrete implementation and not the interface Illuminate\Contracts\Auth\Authenticatable as the method permission() does only exist in the following implementations of said interface: Tinyissue\Model\User.

            unset($fields['time_quote']['fields']['lock']);

            // If quote is locked then remove quote fields
            if ($this->getModel()->isQuoteLocked()) {
                return [];
            }
        }

        return $fields;
    }

    /**
     * @return array
     */
    public function rules()
    {
        $rules = [
            'title' => 'required|max:200',
            'body'  => 'required',
        ];

        return $rules;
    }

    /**
     * @return string
     */
    public function getRedirectUrl()
    {
        if ($this->isEditing()) {
            return $this->getModel()->to('edit');
        }

        return 'project/' . $this->project->id . '/issue/new';
    }

    /**
     * Extract number of hours, or minutes, or seconds from a quote.
     *
     * @param string $part
     *
     * @return float|int
     */
    protected function extractQuoteValue($part)
    {
        if ($this->getModel() instanceof Model\Project\Issue) {
            $seconds = $this->getModel()->time_quote;
            if ($part === 'h') {
                return floor($seconds / 3600);
            }

            if ($part === 'm') {
                return ($seconds / 60) % 60;
            }
        }

        return 0;
    }
}