rias\contactformextensions\ContactFormExtensions::init()

Complexity

Conditions	19
Paths	2

Size

Total Lines	143
Code Lines	83

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function init()
    {
        parent::init();
        self::$plugin = $this;

        if (!Craft::$app->plugins->isPluginInstalled('contact-form') && !Craft::$app->request->getIsConsoleRequest()) {
            Craft::$app->session->setNotice(Craft::t('contact-form-extensions', 'The Contact Form plugin is not installed or activated, Contact Form Extensions does not work without it.'));

The method setNotice() does not exist on null.

        }

        Event::on(View::class, View::EVENT_BEFORE_RENDER_TEMPLATE, function (TemplateEvent $e) {
            if (
                $e->template === 'settings/plugins/_settings' &&
                $e->variables['plugin'] === $this
            ) {
                // Add the tabs
                $e->variables['tabs'] = [
                    ['label' => 'Settings', 'url' => '#settings-tab-settings'],
                    ['label' => 'reCAPTCHA', 'url' => '#settings-tab-recaptcha'],
                ];
            }
        });

        Event::on(UrlManager::class, UrlManager::EVENT_REGISTER_CP_URL_RULES, function (RegisterUrlRulesEvent $event) {
            $event->rules = array_merge($event->rules, [
                'contact-form-extensions/submissions/<submissionId:\d+>'                       => 'contact-form-extensions/submissions/show-submission',
                'contact-form-extensions/submissions/<submissionId:\d+>/<siteHandle:{handle}>' => 'contact-form-extensions/submissions/show-submission',
            ]);
        });

        Event::on(Mailer::class, Mailer::EVENT_BEFORE_SEND, function (SendEvent $e) {
            if ($e->isSpam) {
                return;
            }

            if ($this->settings->recaptcha) {
                $recaptcha = $this->contactFormExtensionsService->getRecaptcha();
                $captchaResponse = Craft::$app->request->getParam('g-recaptcha-response');

                if (!$recaptcha->verifyResponse($captchaResponse, $_SERVER['REMOTE_ADDR'])) {

It seems like $captchaResponse can also be of type array and array; however, parameter $response of AlbertCht\InvisibleReCaptcha\InvisibleReCaptcha::verifyResponse() does only seem to accept string, maybe add an additional type check?

                    $e->isSpam = true;
                    $e->handled = true;

                    return;
                }
            }

            $submission = $e->submission;

            $attNames = [];
            if ($this->settings->attachmentVolumeHandle && $submission->attachment) {
                $volume = Craft::$app->getVolumes()->getVolumeByHandle($this->settings->attachmentVolumeHandle);
                if ($volume) {
                    foreach ($submission->attachment as $attachment) {
                        $date = date_create();
                        $asset = new Asset();
                        $asset->tempFilePath = $attachment->tempName;
                        $asset->filename = $date->getTimestamp().'_'.$attachment->name;
                        $asset->newFolderId = Craft::$app->assets->getRootFolderByVolumeId($volume->id)->id;

Accessing id on the interface craft\base\VolumeInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                        $asset->volumeId = $volume->id;
                        $asset->avoidFilenameConflicts = true;
                        $asset->setScenario(Asset::SCENARIO_CREATE);
                        $result = Craft::$app->getElements()->saveElement($asset);

The assignment to $result is dead and can be removed.

                        array_push($attNames, $asset->filename);
                    }
                }
            }

            if ($this->settings->enableDatabase) {
                $this->contactFormExtensionsService->saveSubmission($submission, implode(', ', $attNames));
            }

            // Set the overridden "toEmail" setting
            if (array_key_exists('toEmail', $e->submission->message)) {

It seems like $e->submission->message can also be of type null and string; however, parameter $search of array_key_exists() does only seem to accept array, maybe add an additional type check?

                $email = Craft::$app->security->validateData($e->submission->message['toEmail']);
                $e->toEmails = explode(',', $email);
            }

            if ($this->settings->enableTemplateOverwrite) {
                // First set the template mode to the Site templates
                Craft::$app->view->setTemplateMode(View::TEMPLATE_MODE_SITE);

                // Render the set template
                $html = Craft::$app->view->renderTemplate(
                    $this->settings->notificationTemplate,
                    ['submission' => $e->submission]
                );

                // Update the message body
                $e->message->setHtmlBody($html);

                // Set the template mode back to Control Panel
                Craft::$app->view->setTemplateMode(View::TEMPLATE_MODE_CP);
            }
        });

        Event::on(Mailer::class, Mailer::EVENT_AFTER_SEND, function (SendEvent $e) {
            if ($this->settings->enableConfirmationEmail) {
                // First set the template mode to the Site templates
                Craft::$app->view->setTemplateMode(View::TEMPLATE_MODE_SITE);

                // Check if template is overridden in form
                $template = null;
                if (array_key_exists('template', $e->submission->message)) {

It seems like $e->submission->message can also be of type null and string; however, parameter $search of array_key_exists() does only seem to accept array, maybe add an additional type check?

                    $template = '_emails\\'.Craft::$app->security->validateData($e->submission->message['template']);
                } else {
                    // Render the set template
                    $template = $this->settings->confirmationTemplate;
                }
                $html = Craft::$app->view->renderTemplate(
                    $template,
                    ['submission' => $e->submission]
                );

                // Create the confirmation email
                $message = new Message();
                $message->setTo($e->submission->fromEmail);
                if (isset(App::mailSettings()->fromEmail)) {
                    $message->setFrom(App::mailSettings()->fromEmail);
                } else {
                    $message->setFrom($e->message->getTo());
                }
                $message->setHtmlBody($html);
                if (array_key_exists('subject', $e->submission)) {

$e->submission of type craft\contactform\models\Submission is incompatible with the type array expected by parameter $search of array_key_exists().

                    $message->setSubject($e->submission->subject);
                } else {
                    $message->setSubject($this->settings->getConfirmationSubject());
                }

                // Send the mail
                Craft::$app->mailer->send($message);

                // Set the template mode back to Control Panel
                Craft::$app->view->setTemplateMode(View::TEMPLATE_MODE_CP);
            }
        });

        Event::on(
            CraftVariable::class,
            CraftVariable::EVENT_INIT,
            function (Event $event) {
                /** @var CraftVariable $variable */
                $variable = $event->sender;
                $variable->set('contactFormExtensions', ContactFormExtensionsVariable::class);
            }