UserController::providePermissions() - Code Metrics - Inspection of "Check permissions before creating user invitation" - FSWebWorks/silverstripe-user-invitation - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#2)

unknown
created 2017-08-18 05:33 UTC
UserController::providePermissions() A

↳ Parent: UserController
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	4
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	6
rs	9.4285
<?php

class UserController extends Controller implements PermissionProvider
filter:
    dependency_paths: ["lib/*"]
{

    private static $allowed_actions = array(

        'index',
        'accept',
        'success',
        'InvitationForm',
        'AcceptForm',
        'expired',
        'notfound'
    );

    public function providePermissions()
    {
         return array(
            'ACCESS_USER_INVITATIONS' => array(
                'name' => _t('UserController.ACCESS_PERMISSIONS', 'Allow user invitations'),
                'name' => /** @scrutinizer ignore-call */ _t('UserController.ACCESS_PERMISSIONS', 'Allow user invitations'),
                'category' => _t('UserController.CMS_ACCESS_CATEGORY', 'User Invitations')
            )
        );
    }


    public function index()
    {
        if (!Member::currentUserID()) {
filter:
    dependency_paths: ["lib/*"]
            return $this->redirect('/Security/login');
        } else if (UserInvitation::create()->canCreate(Member::CurrentUser()) == false){
            return Security::permissionFailure();
filter:
    dependency_paths: ["lib/*"]
        } else return $this->renderWith(array('UserController', 'Page'));
    }

    public function InvitationForm()
    {
        $groups = Member::currentUser()->Groups()->map('Code', 'Title')->toArray();
        $fields = FieldList::create(
filter:
    dependency_paths: ["lib/*"]
            TextField::create('FirstName', _t('UserController.INVITE_FIRSTNAME', 'First name:')),
            TextField::create('FirstName', /** @scrutinizer ignore-call */ _t('UserController.INVITE_FIRSTNAME', 'First name:')),
            EmailField::create('Email', _t('UserController.INVITE_EMAIL', 'Invite email:')),
filter:
    dependency_paths: ["lib/*"]
            ListboxField::create('Groups', _t('UserController.INVITE_GROUP', 'Add to group'), $groups)
filter:
    dependency_paths: ["lib/*"]
                ->setMultiple(true)
                ->setRightTitle(_t('UserController.INVITE_GROUP_RIGHTTITLE', 'Ctrl + click to select multiple'))
        );
        $actions = FieldList::create(
            FormAction::create('sendInvite', _t('UserController.SEND_INVITATION', 'Send Invitation'))
filter:
    dependency_paths: ["lib/*"]
        );
        $requiredFields = RequiredFields::create('FirstName', 'Email');
filter:
    dependency_paths: ["lib/*"]

        if (UserInvitation::config()->get('force_require_group')) {
            $requiredFields->addRequiredField('Groups');
        }

        $form = new Form($this, 'InvitationForm', $fields, $actions, $requiredFields);
filter:
    dependency_paths: ["lib/*"]
        $this->extend('updateInvitationForm', $form);
        return $form;
    }

    /**
     * Records and sends the user's invitation
     * @param $data
     * @param Form $form
     * @return bool|SS_HTTPResponse
filter:
    dependency_paths: ["lib/*"]
     */
    public function sendInvite($data, Form $form)
    {
        if (!$form->validate()) {
            $form->sessionMessage(
                _t(
                /** @scrutinizer ignore-call */ _t(
                    'UserController.SENT_INVITATION_VALIDATION_FAILED',
                    'At least one error occured while trying to save your invite: {error}',
                    array('error' => $form->getValidator()->getErrors()[0]['fieldName'])
                ),
                'bad'
            );
            return $this->redirectBack();
        }

        $invite = UserInvitation::create();
        if ($invite->canCreate(Member::CurrentUser()) == true){
            $form->saveInto($invite);
            try {
                $invite->write();
            } catch (ValidationException $e) {
filter:
    dependency_paths: ["lib/*"]
                $form->sessionMessage(
                    $e->getMessage(),
                    'bad'
                );
                return $this->redirectBack();
            }
            $invite->sendInvitation();

            $form->sessionMessage(
                _t(
                    'UserController.SENT_INVITATION',
                    'An invitation was sent to {email}.',
                    array('email' => $data['Email'])
                ),
                'good'
            );
            return $this->redirectBack();
        } else {
            $form->sessionMessage(
                "You don't have permission to create user invitations",
                'bad'
            );
            return $this->redirectBack();
        }
    }


    public function accept()
    {
        if (!$hash = $this->getRequest()->param('ID')) {
            return $this->forbiddenError();
        }
        if ($invite = UserInvitation::get()->filter('TempHash', $hash)->first()) {
            if ($invite->isExpired()) {
                return $this->redirect($this->Link('expired'));
            }
        } else {
            return $this->redirect($this->Link('notfound'));
        }
        return $this->renderWith(array('UserController_accept', 'Page'), array('Invite' => $invite));
    }

    public function AcceptForm()
    {
        $hash = $this->getRequest()->param('ID');
        $invite = UserInvitation::get()->filter('TempHash', $hash)->first();
        $firstName = ($invite) ? $invite->FirstName : '';

        $fields = FieldList::create(
            TextField::create(
                'FirstName',
                _t('UserController.ACCEPTFORM_FIRSTNAME', 'First name:'),
                /** @scrutinizer ignore-call */ _t('UserController.ACCEPTFORM_FIRSTNAME', 'First name:'),
                $firstName
            ),
            TextField::create('Surname', _t('UserController.ACCEPTFORM_SURNAME', 'Surname:')),
            ConfirmedPasswordField::create('Password'),
filter:
    dependency_paths: ["lib/*"]
            HiddenField::create('HashID')->setValue($hash)
filter:
    dependency_paths: ["lib/*"]
        );
        $actions = FieldList::create(
            FormAction::create('saveInvite', _t('UserController.ACCEPTFORM_REGISTER', 'Register'))
        );
        $requiredFields = RequiredFields::create('FirstName', 'Surname');
        $form = new  Form($this, 'AcceptForm', $fields, $actions, $requiredFields);
        Session::set('UserInvitation.accepted', true);
        $this->extend('updateAcceptForm', $form);
        return $form;
    }

    /**
     * @param $data
     * @param Form $form
     * @return bool|SS_HTTPResponse
     */
    public function saveInvite($data, Form $form)
    {
        if (!$invite = UserInvitation::get()->filter('TempHash', $data['HashID'])->first()) {
            return $this->notFoundError();
        }
        if ($form->validate()) {
            $member = Member::create(array('Email' => $invite->Email));
            $form->saveInto($member);
            try {
                if ($member->validate()) {
                    $member->write();
                    // Add user group info
                    $groups = explode(',', $invite->Groups);
                    foreach ($groups as $groupCode) {
                        $member->addToGroupByCode($groupCode);
                    }
                }
            } catch (ValidationException $e) {
                $form->sessionMessage(
                    $e->getMessage(),
                    'bad'
                );
                return $this->redirectBack();
            }
            // Delete invitation
            $invite->delete();
            return $this->redirect($this->Link('success'));
        } else {
            $form->sessionMessage(
                Convert::array2json($form->getValidator()->getErrors()),
filter:
    dependency_paths: ["lib/*"]
                'bad'
            );
            return $this->redirectBack();
        }
    }

    public function success()
    {
        return $this->renderWith(
            array('UserController_success', 'Page'),
            array('BaseURL' => Director::absoluteBaseURL())
        );
    }

    public function expired()
    {
        return $this->renderWith(array('UserController_expired', 'Page'));
    }

    public function notfound()
    {
        return $this->renderWith(array('UserController_notfound', 'Page'));
    }

    private function forbiddenError()
    {
        return $this->httpError(403, _t('UserController.403_NOTICE', 'You must be logged in to access this page.'));
        return $this->httpError(403, /** @scrutinizer ignore-call */ _t('UserController.403_NOTICE', 'You must be logged in to access this page.'));
    }

    private function notFoundError()
    {
        return $this->redirect($this->Link('notfound'));
    }

    /**
     * Ensure that links for this controller use the customised route.
     * Searches through the rules set up for the class and returns the first route.
     *
     * @param  string $action
     * @return string
     */
    public function Link($action = null)
    {
        if ($url = array_search(get_called_class(), (array)Config::inst()->get('Director', 'rules'))) {
filter:
    dependency_paths: ["lib/*"]
            // Check for slashes and drop them
            if ($indexOf = stripos($url, '/')) {
                $url = substr($url, 0, $indexOf);
            }
            return $this->join_links($url, $action);
        }
    }
}

FSWebWorks / silverstripe-user-invitation

Pull Request — master (#2)

UserController::providePermissions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
