LeKoala\EmailTemplates\Tasks\EmailImportTask::run()

Complexity

Conditions	54
Paths	> 20000

Size

Total Lines	278
Code Lines	159

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

<?php
    public function run($request)
    {
        $subsiteSupport = SubsiteHelper::usesSubsite();
        $fluentSupport = FluentHelper::usesFluent();

        echo 'Run with ?clear=1 to clear empty database before running the task<br/>';
        echo 'Run with ?overwrite=soft|hard to overwrite templates that exists in the cms. Soft will replace template if not modified by the user, hard will replace template even if modified by user.<br/>';
        echo 'Run with ?templates=xxx,yyy to specify which template should be imported<br/>';
        if ($subsiteSupport) {
            echo 'Run with ?subsite=all|subsiteID to create email templates in all subsites (including main site) or only in the chosen subsite (if a subsite is active, it will be used by default).<br/>';
        }
        if ($fluentSupport) {
            echo 'Run with ?locales=fr,en to choose which locale to import.<br/>';
        }
        echo '<strong>Remember to flush the templates/translations if needed</strong><br/>';
        echo '<hr/>';

        $overwrite = $request->getVar('overwrite');
        $clear = $request->getVar('clear');
        $templatesToImport = $request->getVar('templates');
        $importToSubsite = $request->getVar('subsite');

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

        $chosenLocales = $request->getVar('locales');

        // Normalize argument
        if ($overwrite && $overwrite != 'soft' && $overwrite != 'hard') {
            $overwrite = 'soft';
        }

        // Select which subsite to import emails to
        $importToSubsite = array();
        if ($subsiteSupport) {
            $subsites = array();
            if ($importToSubsite == 'all') {

The condition $importToSubsite == 'all' is always false.

                $subsites = SubsiteHelper::listSubsites();
            } elseif (is_numeric($importToSubsite)) {

The condition is_numeric($importToSubsite) is always false.

                $subsites = SubsiteHelper::listSubsites();
                $subsiteTitle = 'Subsite #' . $importToSubsite;
                foreach ($subsites as $subsite) {
                    if ($subsite->ID == $importToSubsite) {
                        $subsiteTitle = $subsite->Title;
                    }
                }
                $subsites = array(
                    $importToSubsite => $subsiteTitle
                );
            }
            if ($subsiteSupport && SubsiteHelper::currentSubsiteID()) {
                DB::alteration_message("Importing to current subsite. Run from main site to import other subsites at once.", "created");
                $subsites = array();
            }
            if (!empty($subsites)) {
                DB::alteration_message("Importing to subsites : " . implode(',', array_values($subsites)), "created");
            }
        }

        if ($templatesToImport) {
            $templatesToImport = explode(',', $templatesToImport);
        }

        // Do we clear our templates?
        if ($clear == 1) {
            DB::alteration_message("Clear all email templates", "created");
            $emailTemplates = EmailTemplate::get();
            foreach ($emailTemplates as $emailTemplate) {
                $emailTemplate->delete();
            }
        }

        $emailTemplateSingl = singleton(EmailTemplate::class);

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

        $locales = null;
        if ($fluentSupport) {
            if (FluentHelper::isClassTranslated(EmailTemplate::class)) {
                $locales = Locale::get()->column('Locale');

                // We collect only one locale, restrict the list
                if ($chosenLocales) {
                    $arr = explode(',', $chosenLocales);
                    $locales = array();
                    foreach ($arr as $a) {
                        $a = FluentHelper::get_locale_from_lang($a);
                        $locales[] = $a;
                    }
                }
            }
        }

        $defaultLocale = FluentHelper::get_locale();

        $templates = $this->collectTemplates();

        // don't throw errors
        Config::modify()->set(i18n::class, 'missing_default_warning', false);

        foreach ($templates as $filePath) {
            $isOverwritten = false;

            $fileName = basename($filePath, '.ss');

            // Remove base path
            $relativeFilePath = str_replace(Director::baseFolder(), '', $filePath);
            $relativeFilePathParts = explode('/', trim($relativeFilePath, '/'));

            // Group by module
            $moduleName = array_shift($relativeFilePathParts);
            if ($moduleName == 'vendor') {
                $moduleVendor = array_shift($relativeFilePathParts);
                // get module name
                $moduleName = $moduleVendor . '/' . array_shift($relativeFilePathParts);
            }

            // remove /templates part
            array_shift($relativeFilePathParts);
            $templateName = str_replace('.ss', '', implode('/', $relativeFilePathParts));

            $templateTitle = basename($templateName);

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

            // Create the email code (basically, the template name without "Email" at the end)
            $code = preg_replace('/Email$/', '', $fileName);

            if (!empty($templatesToImport) && !in_array($code, $templatesToImport)) {
                DB::alteration_message("Template with code <b>$code</b> was ignored.", "repaired");
                continue;
            }

            $whereCode = array(
                'Code' => $code
            );
            $emailTemplate = EmailTemplate::get()->filter($whereCode)->first();

            // Check if it has been modified or not
            $templateModified = false;
            if ($emailTemplate) {
                $templateModified = $emailTemplate->Created != $emailTemplate->LastEdited;
            }

            if (!$overwrite && $emailTemplate) {
                DB::alteration_message("Template with code <b>$code</b> already exists. Choose overwrite if you want to import again.", "repaired");
                continue;
            }
            if ($overwrite == 'soft' && $templateModified) {
                DB::alteration_message("Template with code <b>$code</b> has been modified by the user. Choose overwrite=hard to change.", "repaired");
                continue;
            }

            // Create a default title from code
            $title = preg_split('/(?=[A-Z])/', $code);
            $title = implode(' ', $title);

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

It seems like $title can also be of type false; however, parameter $pieces of implode() does only seem to accept array, maybe add an additional type check?

            // Get content of the email
            $content = file_get_contents($filePath);

            // Analyze content to find incompatibilities
            $errors = self::checkContentForErrors($content);
            if (!empty($errors)) {
                echo "<div style='color:red'>Invalid syntax was found in '$relativeFilePath'. Please fix these errors before importing the template<ul>";
                foreach ($errors as $error) {
                    echo '<li>' . $error . '</li>';
                }
                echo '</ul></div>';
                continue;
            }

            // Parse language
            $module = ModuleLoader::getModule($moduleName);
            $collector = new i18nTextCollector;
            $entities = $collector->collectFromTemplate($content, $fileName, $module);

            /*
            array:1 [▼
            "MyEmail.SUBJECT" => "My subject"
            ]
            */

            $translationTable = array();
            foreach ($entities as $entity => $data) {
                if ($locales) {
                    foreach ($locales as $locale) {
                        i18n::set_locale($locale);
                        if (!isset($translationTable[$entity])) {
                            $translationTable[$entity] = array();
                        }
                        $translationTable[$entity][$locale] = i18n::_t($entity, $data);
                    }
                    i18n::set_locale($defaultLocale);
                } else {
                    $translationTable[$entity] = array($defaultLocale => i18n::_t($entity, $data));
                }
            }

            $contentLocale = array();
            // May be null
            if ($locales) {
                foreach ($locales as $locale) {
                    $contentLocale[$locale] = $content;
                }
            }
            if (!isset($contentLocale[$defaultLocale])) {
                $contentLocale[$defaultLocale] = $content;
            }

            // Now we use our translation table to manually replace _t calls into file content
            foreach ($translationTable as $entity => $translationData) {
                // use the double escape notation
                $escapedEntity = str_replace('\\', '\\\\\\\\', $entity);
                // fix dot notation
                $escapedEntity = str_replace('.', '\.', $escapedEntity);
                $baseTranslation = null;

                foreach ($translationData as $locale => $translation) {
                    if (!$baseTranslation && $translation) {
                        $baseTranslation = $translation;
                    }
                    if (!$translation) {
                        $translation = $baseTranslation;
                    }
                    // This regex should match old and new style
                    $count = 0;
                    $contentLocale[$locale] = preg_replace("/<%(t | _t\(')" . $escapedEntity . "( |').*?%>/ums", $translation, $contentLocale[$locale], -1, $count);
                    if (!$count) {
                        throw new Exception("Failed to replace $escapedEntity with translation $translation");
                    }
                }
            }

            // Create a template if necassery or mark as overwritten
            if (!$emailTemplate) {
                $emailTemplate = new EmailTemplate;
            } else {
                $isOverwritten = true;
            }

            // Other properties
            $emailTemplate->Code = $code;
            $emailTemplate->Category = $moduleName;
            if (SubsiteHelper::currentSubsiteID() && !$emailTemplate->SubsiteID) {

The property SubsiteID does not exist on LeKoala\EmailTemplates\Models\EmailTemplate. Since you implemented __get, consider adding a @property annotation.

                $emailTemplate->SubsiteID = SubsiteHelper::currentSubsiteID();

The property SubsiteID does not exist on LeKoala\EmailTemplates\Models\EmailTemplate. Since you implemented __set, consider adding a @property annotation.

            }
            // Write to main site or current subsite
            $emailTemplate->write();

            // Apply content to email after write to ensure we can localize properly
            $this->assignContent($emailTemplate, $contentLocale[$defaultLocale]);

            if (!empty($locales)) {
                foreach ($locales as $locale) {
                    $this->assignContent($emailTemplate, $contentLocale[$locale], $locale);
                }
            }

            // Reset date to allow tracking user edition (for soft/hard overwrite)
            $this->resetLastEditedDate($emailTemplate->ID);

            // Loop through subsites
            if (!empty($importToSubsite)) {
                SubsiteHelper::disableFilter();
                foreach ($subsites as $subsiteID => $subsiteTitle) {

The variable $subsites does not seem to be defined for all execution paths leading up to this point.

                    $whereCode['SubsiteID'] = $subsiteID;

                    $subsiteEmailTemplate = EmailTemplate::get()->filter($whereCode)->first();

                    $emailTemplateCopy = $emailTemplate;
                    $emailTemplateCopy->SubsiteID = $subsiteID;
                    if ($subsiteEmailTemplate) {
                        $emailTemplateCopy->ID = $subsiteEmailTemplate->ID;
                    } else {
                        $emailTemplateCopy->ID = 0; // New
                    }
                    $emailTemplateCopy->write();

                    $this->resetLastEditedDate($emailTemplateCopy->ID);
                }
            }

            if ($isOverwritten) {
                DB::alteration_message("Overwrote <b>{$emailTemplate->Code}</b>", "created");
            } else {
                DB::alteration_message("Imported <b>{$emailTemplate->Code}</b>", "created");
            }