Updater::queueUpdate() - Code Metrics - Inspection of "In progress..." - satrun77/tinyissue - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — develop-3.0 (ae28cb)

by Mohamed
created 2016-09-29 09:17 UTC
Updater::queueUpdate() C

↳ Parent: Updater
Complexity

Conditions	7
Paths	6
Size

Total Lines	31
Code Lines	13
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	31
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	13
nc	6
nop	2
<?php

/*
 * This file is part of the Tinyissue package.
 *
 * (c) Mohamed Alsharaf <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tinyissue\Repository\Project\Issue;

use Illuminate\Support\Collection;
use Tinyissue\Contracts\Model\UserInterface;
use Tinyissue\Model\Activity;
use Tinyissue\Model\Message\Queue;
use Tinyissue\Model\Project;
use Tinyissue\Model\Tag;
use Tinyissue\Model\User;
use Tinyissue\Repository\RepositoryUpdater;

class Updater extends RepositoryUpdater
{
    public function __construct(Project\Issue $model)
    {
        $this->model = $model;
    }

    /**
     * Set the issue is updated by a user.
     *
     * @param int $userId
     *
     * @return Project\Issue
     */
    public function changeUpdatedBy($userId)
    {
        $this->model->updated_by = $userId;
        $this->model->touch();

        return $this->save();
    }

    /**
     * Reassign the issue to a new user.
     *
     * @param int|UserInterface $assignTo
     * @param UserInterface     $user
     *
     * @return Project\Issue
     */
    public function reassign($assignTo, UserInterface $user)
    {
        $this->setUser($user);
        $assignToId               = !$assignTo instanceof UserInterface ? $assignTo : $assignTo->id;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $this->model->assigned_to = $assignToId;

        // Add event on successful save
        Project\Issue::saved(function (Project\Issue $issue) {
            $this->queueAssign($issue, $this->user);
        });

        $this->save();

        $this->saveToActivities([
            'type_id'   => Activity::TYPE_REASSIGN_ISSUE,
            'parent_id' => $this->model->project->id,
            'user_id'   => $user->id,
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            'action_id' => $this->model->assigned_to,
        ]);

        return $this->model;
    }

    /**
     * Update the given issue.
     *
     * @param array $input
     *
     * @return Project\Issue
     */
    public function update(array $input = [])
    {
        $fill = array_only($input, [
            'title', 'body', 'assigned_to',
        ]);
        $fill['updated_by'] = $this->model->updatedBy->id;

        if (isset($input['time_quote']['lock'])) {
            $fill['lock_quote'] = $input['time_quote']['lock'];
        }

        // Only save quote if not locked or locked & user allowed to modify it
        if (array_key_exists('time_quote', $input) &&
            (!$this->model->isQuoteLocked() || $this->getLoggedUser()->can('lockQuote', $this->model))
        ) {
            $fill['time_quote'] = $input['time_quote'];
        }

        /* Add to activity log for assignment if changed */
        $assignToId = (int) array_get($input, 'assigned_to');
        if ($assignToId > 0 && $assignToId !== (int) $this->model->assigned_to) {
            $this->saveToActivities([
                'type_id'   => Activity::TYPE_REASSIGN_ISSUE,
                'parent_id' => $this->model->project->id,
                'user_id'   => $this->model->updatedBy->id,
                'action_id' => $this->model->assigned_to,
            ]);
        }

        $this->model->fill($fill);

        $this->syncTags($input, $this->model->tags()->with('parent')->get());

        // Add event on successful save
        Project\Issue::saved(function (Project\Issue $issue) {
            $this->queueUpdate($issue, $this->user);
        });

        return $this->save();
    }

    /**
     * Create a new issue.
     *
     * @param array $input
     *
     * @return Project\Issue
     */
    public function create(array $input)
    {
        if (array_key_exists('project_id', $input)) {
            $this->model->setRelation('project', Project::find((int) $input['project_id']));
        }

        $fill = [
            'created_by'  => $this->model->user->id,
            'project_id'  => $this->model->project->id,
            'title'       => $input['title'],
            'body'        => $input['body'],
            'assigned_to' => (int) $this->model->project->default_assignee,
        ];

        if ($this->model->user->isDeveloperOrMore()) {
            $fill['assigned_to'] = array_get($input, 'assigned_to', $fill['assigned_to']);
            $fill['time_quote']  = array_get($input, 'time_quote');
        }

        $this->model->fill($fill)->save();

        // Add issue to messages queue
        $this->queueAdd($this->model, $this->user);


        /* Add to user's activity log */
        $this->saveToActivities([
            'type_id'   => Activity::TYPE_CREATE_ISSUE,
            'parent_id' => $this->model->project->id,
            'user_id'   => $this->model->user->id,
        ]);

        /* Add attachments to issue */
        Project\Issue\Attachment::instance()->updateIssueToken($input['upload_token'], $this->model->user->id, $this->model->id);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        // Add default tag to newly created issue
        $defaultTag = app('tinyissue.settings')->getFirstStatusTagId();
        if ($defaultTag > 0 && empty($input['tag_status'])) {
            $input['tag_status'] = $defaultTag;
        }

        $this->syncTags($input);

        return $this->model;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Move the issue (comments & activities) to another project.
     *
     * @param int $projectId
     *
     * @return Project\Issue
     */
    public function changeProject($projectId)
    {
        $this->model->project_id = $projectId;
        $this->save();
        $comments = $this->model->comments()->get();
        foreach ($comments as $comment) {
            $comment->project_id = $projectId;
            $comment->save();
        }

        $activities = $this->model->activities()->get();
        foreach ($activities as $activity) {
            $activity->parent_id = $projectId;
            $activity->save();
        }

        return $this->model;
    }

    /**
     * Delete an issue.
     *
     * @return bool
     *
     * @throws \Exception
     */
    public function delete()
    {
        return $this->transaction('deleteIssue');
    }

    protected function deleteIssue()
    {
        $id          = $this->model->id;
        $projectId   = $this->model->project_id;
        $comments    = $this->model->comments;
        $attachments = $this->model->attachments;

        $status = $this->model->delete();

        if ($status) {
            $attachments->each(function (Project\Issue\Attachment $attachment) use ($projectId) {
                $path = $this->getUploadStorage($projectId, $attachment->upload_token);
                $attachment->deleteFile($path, $attachment->filename);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                $attachment->delete();
            });
            $comments->each(function (Project\Issue\Comment $comment) {
                $comment->deleteComment($this->getLoggedUser()->user());
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            });
            User\Activity::where('parent_id', '=', $projectId)->where('item_id', '=', $id)->delete();
            \DB::table('projects_issues_tags')->where('issue_id', '=', $id)->delete();
        }

        return $status;
    }

    /**
     * Change the status of an issue.
     *
     * @param int           $status
     * @param UserInterface $user
     *
     * @return Project\Issue
     */
    public function changeStatus($status, UserInterface $user)
    {
        if ($status == 0) {
            $this->model->closed_by = $user->id;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $this->model->closed_at = (new \DateTime())->format('Y-m-d H:i:s');
            $activityType           = Activity::TYPE_CLOSE_ISSUE;
        } else {
            $this->model->closed_by = 0;
            $this->model->closed_at = null;
            $activityType           = Activity::TYPE_REOPEN_ISSUE;
        }

        /* Add to activity log */
        $this->saveToActivities([
            'type_id'   => $activityType,
            'parent_id' => $this->model->project->id,
            'user_id'   => $user->id,
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        ]);

        $this->model->status = $status;

        // Add event on successful save
        Project\Issue::saved(function (Project\Issue $issue) {
            $this->queueUpdate($issue, $this->user);
        });

        return $this->save();
    }

    /**
     * Sync the issue tags.
     *
     * @param array      $input
     * @param Collection $currentTags
     *
     * @return bool
     */
    public function syncTags(array $input, Collection $currentTags = null)
    {
        $tagIds = array_only($input, [
            'tag_type', 'tag_status', 'tag_resolution',
        ]);

        // User can edit their own role and can only change issue type
        if ($this->model->updatedBy instanceof UserInterface && $this->model->updatedBy->isUser()) {
            $currentTagIds            = $currentTags->pluck('id', 'parent.name')->toArray();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
            $tagIds['tag_status']     = array_key_exists('status', $currentTagIds) ? $currentTagIds['status'] : 0;
            $tagIds['tag_resolution'] = array_key_exists('resolution', $currentTagIds) ? $currentTagIds['resolution'] : 0;
        }

        $tags = (new Tag())->whereIn('id', $tagIds)->get();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        $removedTags = [];
        if (null === $currentTags) {
            // Add the following tags except for open status
            $addedTags = $tags
                ->map(function (Tag $tag) {
                    return $tag->toShortArray();
                })
                ->toArray();
        } else {
            // Tags remove from the issue
            $removedTags = $currentTags
                ->diff($tags)
                ->map(function (Tag $tag) {
                    return $tag->toShortArray();
                })
                ->toArray();

            // Check if we are adding new tags
            $addedTags = $tags
                ->filter(function (Tag $tag) use ($currentTags) {
                    return $currentTags->where('id', $tag->id)->count() === 0;
                })
                ->map(function (Tag $tag) {
                    return $tag->toShortArray();
                })
                ->toArray();

            // No new tags to add or remove
            if (empty($removedTags) && empty($addedTags)) {
                return true;
            }
        }

        // Save relation
        $this->model->tags()->sync($tags->pluck('id')->all());

        // Activity is added when new issue create with tags or updated with tags excluding the open status tag
        if (!empty($removedTags) || !empty($addedTags)) {
            // Add this change to messages queue
            $this->queueChangeTags($this->model, $addedTags, $removedTags, $this->user);


            // Add to activity log for tags if changed
            $this->saveToActivities([
                'type_id'   => Activity::TYPE_ISSUE_TAG,
                'parent_id' => $this->model->project->id,
                'user_id'   => $this->model->user->id,
                'data'      => ['added_tags' => $addedTags, 'removed_tags' => $removedTags],
            ]);
        }

        return true;
    }

    /**
     * Add tag to the issue & close issue if added tag is Closed.
     *
     * @param Tag $newTag
     * @param Tag $oldTag
     *
     * @return Project\Issue
     */
    public function changeKanbanTag(Tag $newTag, Tag $oldTag)
    {
        //  skip if there is no change in status tags
        if ($oldTag->name === $newTag->name) {
            return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // Open issue
        $data = ['added_tags' => [], 'removed_tags' => []];

        // Remove previous status tag
        $this->model->tags()->detach($oldTag);
        $data['removed_tags'][] = $oldTag->toShortArray();

        // Add new tag
        if (!$this->model->tags->contains($newTag)) {
            $this->model->tags()->attach($newTag);

            $data['added_tags'][] = $newTag->toShortArray();
        }

        if (!empty($data)) {
            // Add this change to messages queue
            $this->queueChangeTags($this->model, $data['added_tags'], $data['removed_tags'], $this->user);


            // Add to activity log for tags if changed
            $this->saveToActivities([
                'type_id'   => Activity::TYPE_ISSUE_TAG,
                'parent_id' => $this->model->project->id,
                'user_id'   => $this->model->user->id,
                'data'      => $data,
            ]);
        }

        return $this->model;
    }

    /**
     * Insert update issue to message queue.
     *
     * @param Project\Issue $issue
     * @param UserInterface $changeBy
     *
     * @return void
     */
    public function queueUpdate(Project\Issue $issue, UserInterface $changeBy)
    {
        // Number of changed attributes
        $countChanges = count($issue->getDirty());

        // Whether or not the assignee has changed
        $noMessageForMe = false;

        // is Closed?
        if (!$issue->isOpen()) {
            return (new Queue())->queue(Queue::CLOSE_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        // is Reopened?
        if ((int) $issue->getOriginal('status') === Project\Issue::STATUS_CLOSED) {
            return (new Queue())->queue(Queue::REOPEN_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }

        // If the assignee has changed and it is not the logged in user who made the action
        if ($issue->assigned_to !== $issue->getOriginal('assigned_to', $issue->assigned_to)
            && $changeBy->id !== $issue->assigned_to
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        ) {
            (new Queue())->queue(Queue::ASSIGN_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $noMessageForMe = $issue->assigned_to;
        }

        // If the update was just for assigning user, then skip update issue
        if (!($countChanges === 1 && $noMessageForMe !== false)) {
            return (new Queue())->queue(Queue::UPDATE_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }
    }

    /**
     * Insert add issue to message queue.
     *
     * @param Project\Issue $issue
     * @param UserInterface $changeBy
     *
     * @return void
     */
    public function queueAdd(Project\Issue $issue, UserInterface $changeBy)
    {
        return (new Queue())->queue(Queue::ADD_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /**
     * Insert assign issue to message queue.
     *
     * @param Project\Issue $issue
     * @param UserInterface $changeBy
     *
     * @return void
     */
    public function queueAssign(Project\Issue $issue, UserInterface $changeBy)
    {
        // If the assignee has changed and it is not the logged in user who made the action
        if ($issue->assigned_to > 0 && $changeBy->id !== $issue->assigned_to) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            return (new Queue())->queue(Queue::ASSIGN_ISSUE, $issue, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        }
    }

    /**
     * Insert issue tag changes to message queue.
     *
     * @param Project\Issue $issue
     * @param array         $addedTags
     * @param array         $removedTags
     * @param UserInterface $changeBy
     *
     * @return mixed
     */
    public function queueChangeTags(Project\Issue $issue, array $addedTags, array $removedTags, UserInterface $changeBy)
    {
        return (new Queue())->queueIssueTagChanges($issue, $addedTags, $removedTags, $changeBy);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }
}

Branch — develop-3.0 (ae28cb)

Updater::queueUpdate() C

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

satrun77 / tinyissue

Branch — develop-3.0 (ae28cb)

Updater::queueUpdate() C

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
