nystudio107\seomatic\helpers\Sitemap::generateSitemap()

Complexity

Conditions	76
Paths	> 20000

Size

Total Lines	378
Code Lines	248

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	5852

Importance

Changes	10
Bugs	3	Features	1

<?php
    public static function generateSitemap(array $params): ?string
    {
        $groupId = $params['groupId'];
        $type = $params['type'];
        $handle = $params['handle'];
        $siteId = $params['siteId'];
        $page = $params['page'];

        // Get an array of site ids for this site group
        $groupSiteIds = [];

        if (Seomatic::$settings->siteGroupsSeparate) {
            if (empty($groupId)) {
                try {
                    $thisSite = Craft::$app->getSites()->getSiteById($siteId);
                    if ($thisSite !== null) {
                        $group = $thisSite->getGroup();
                        $groupId = $group->id;
                    }
                } catch (Throwable $e) {
                    Craft::error($e->getMessage(), __METHOD__);
                }
            }
            $siteGroup = Craft::$app->getSites()->getGroupById($groupId);
            if ($siteGroup !== null) {
                $groupSiteIds = $siteGroup->getSiteIds();
            }
        }

        if (empty($groupSiteIds)) {
            $groupSiteIds = Craft::$app->getSites()->allSiteIds;
        }

        $lines = [];
        // Sitemap index XML header and opening tag
        $lines[] = '<?xml version="1.0" encoding="UTF-8"?>';
        $lines[] = '<?xml-stylesheet type="text/xsl" href="sitemap.xsl"?>';
        // One sitemap entry for each element
        $metaBundle = Seomatic::$plugin->metaBundles->getMetaBundleBySourceHandle(
            $type,
            $handle,
            $siteId
        );
        // If it doesn't exist, exit
        if ($metaBundle === null) {
            return null;
        }
        $multiSite = count($metaBundle->sourceAltSiteSettings) > 1;
        $totalElements = null;
        $urlsetLine = '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
        if ($metaBundle->metaSitemapVars->sitemapAssets) {
            $urlsetLine .= ' xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"';
            $urlsetLine .= ' xmlns:video="http://www.google.com/schemas/sitemap-video/1.1"';
        }
        if ($multiSite) {
            $urlsetLine .= ' xmlns:xhtml="http://www.w3.org/1999/xhtml"';
        }
        if ((bool)$metaBundle->metaSitemapVars->newsSitemap) {
            $urlsetLine .= ' xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"';
        }
        $urlsetLine .= '>';
        $lines[] = $urlsetLine;

        // Get all of the elements for this meta bundle type
        $seoElement = Seomatic::$plugin->seoElements->getSeoElementByMetaBundleType($metaBundle->sourceBundleType);

        if ($seoElement !== null) {
            // Ensure `null` so that the resulting element query is correct
            if (empty($metaBundle->metaSitemapVars->sitemapLimit)) {
                $metaBundle->metaSitemapVars->sitemapLimit = null;
            }

            $totalElements = $seoElement::sitemapElementsQuery($metaBundle)->count();
            if ($metaBundle->metaSitemapVars->sitemapLimit && ($totalElements > $metaBundle->metaSitemapVars->sitemapLimit)) {

The expression $metaBundle->metaSitemapVars->sitemapLimit of type integer|null is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

                $totalElements = $metaBundle->metaSitemapVars->sitemapLimit;
            }
        }

        // If no elements exist, just exit
        if (!$totalElements) {
            return null;
        }

        // Stash the sitemap attributes so they can be modified on a per-entry basis
        $stashedSitemapAttrs = $metaBundle->metaSitemapVars->getAttributes();

The method getAttributes() does not exist on null.

        $stashedGlobalVarsAttrs = $metaBundle->metaGlobalVars->getAttributes();

The method getAttributes() does not exist on null.

        // Use craft\db\Paginator to paginate the results so we don't exceed any memory limits
        // See batch() and each() discussion here: https://github.com/yiisoft/yii2/issues/8420
        // and here: https://github.com/craftcms/cms/issues/7338

        $elementQuery = $seoElement::sitemapElementsQuery($metaBundle);
        $sitemapPageSize = $metaBundle->metaSitemapVars->sitemapPageSize;
        $elementQuery->limit($metaBundle->metaSitemapVars->sitemapLimit ?? null);

        // If this is not a paged sitemap, go through full results
        if (is_null($sitemapPageSize)) {
            $pagedSitemap = false;
            $paginator = new Paginator($elementQuery, [
                'pageSize' => self::SITEMAP_QUERY_PAGE_SIZE,
            ]);
            $elements = $paginator->getPageResults();
        } else {
            $sitemapPage = empty($page) ? 1 : $page;
            $pagedSitemap = true;
            $elementQuery->limit($sitemapPageSize);
            $elementQuery->offset(($sitemapPage - 1) * $sitemapPageSize);
            $elements = $elementQuery->all();
            $totalElements = $sitemapPageSize;
            $paginator = new Paginator($elementQuery, [
                'pageSize' => $sitemapPageSize,
            ]);
        }

        $currentElement = 1;

        do {
            if (Craft::$app instanceof ConsoleApplication) {
                if ($pagedSitemap) {
                    $message = sprintf('Query %d elements', $sitemapPageSize);
                } else {
                    $message = sprintf('Query %d / %d - elements: %d',
                        $paginator->getCurrentPage(),
                        $paginator->getTotalPages(),
                        $paginator->getTotalResults());
                }
                echo $message . PHP_EOL;
            }
            /** @var Element $element */
            foreach ($elements as $element) {
                // Output some info if this is a console app
                if (Craft::$app instanceof ConsoleApplication) {
                    echo "Processing element {$currentElement}/{$totalElements} - {$element->title}" . PHP_EOL;
                }

                $metaBundle->metaSitemapVars->setAttributes($stashedSitemapAttrs, false);
                $metaBundle->metaGlobalVars->setAttributes($stashedGlobalVarsAttrs, false);
                // Combine in any per-entry type settings
                self::combineEntryTypeSettings($seoElement, $element, $metaBundle);
                // Make sure this entry isn't disabled
                self::combineFieldSettings($element, $metaBundle);
                // Special case for the __home__ URI
                $path = ($element->uri === '__home__') ? '' : $element->uri;
                // Check to see if robots is `none` or `no index`
                $robotsEnabled = true;
                if (!empty($metaBundle->metaGlobalVars->robots)) {
                    $robotsEnabled = $metaBundle->metaGlobalVars->robots !== 'none' &&
                        $metaBundle->metaGlobalVars->robots !== 'noindex';
                }
                $enabled = true;
                if (Seomatic::$craft34) {
                    $enabled = $element->getEnabledForSite($metaBundle->sourceSiteId);
                }
                $enabled = $enabled && $path !== null && $metaBundle->metaSitemapVars->sitemapUrls && $robotsEnabled;
                $event = new IncludeSitemapEntryEvent([
                    'include' => $enabled,
                    'element' => $element,
                    'metaBundle' => $metaBundle,
                ]);
                Event::trigger(self::class, self::EVENT_INCLUDE_SITEMAP_ENTRY, $event);
                // Only add in a sitemap entry if it meets our criteria
                if ($event->include) {
                    // Get the url and canonicalUrl
                    try {
                        $url = UrlHelper::siteUrl($path, null, null, $metaBundle->sourceSiteId);
                    } catch (Exception $e) {
                        $url = '';
                    }
                    $url = UrlHelper::absoluteUrlWithProtocol($url);
                    if (Seomatic::$settings->excludeNonCanonicalUrls) {
                        Seomatic::$matchedElement = $element;
                        MetaValue::cache();
                        $path = $metaBundle->metaGlobalVars->parsedValue('canonicalUrl');
                        try {
                            $canonicalUrl = UrlHelper::siteUrl($path, null, null, $metaBundle->sourceSiteId);
                        } catch (Exception $e) {
                            $canonicalUrl = '';
                        }
                        $canonicalUrl = UrlHelper::absoluteUrlWithProtocol($canonicalUrl);
                        if ($url !== $canonicalUrl) {
                            Craft::info("Excluding URL: {$url} from the sitemap because it does not match the Canonical URL: {$canonicalUrl} - " . $metaBundle->metaGlobalVars->canonicalUrl . " - " . $element->uri);

Are you sure $metaBundle->metaGlobalVars->canonicalUrl of type object|string can be used in concatenation?

                            continue;
                        }
                    }
                    $dateUpdated = $element->dateUpdated ?? $element->dateCreated ?? new DateTime();
                    $lines[] = '<url>';
                    // Standard sitemap key/values
                    $lines[] = '<loc>';
                    $lines[] = Html::encode($url);
                    $lines[] = '</loc>';
                    $lines[] = '<lastmod>';
                    $lines[] = $dateUpdated->format(DateTime::W3C);
                    $lines[] = '</lastmod>';
                    $lines[] = '<changefreq>';
                    $lines[] = $metaBundle->metaSitemapVars->sitemapChangeFreq;
                    $lines[] = '</changefreq>';
                    $lines[] = '<priority>';
                    $lines[] = $metaBundle->metaSitemapVars->sitemapPriority;
                    $lines[] = '</priority>';
                    // Handle alternate URLs if this is multi-site
                    if ($multiSite && $metaBundle->metaSitemapVars->sitemapAltLinks) {
                        $primarySiteId = Craft::$app->getSites()->getPrimarySite()->id;
                        foreach ($metaBundle->sourceAltSiteSettings as $altSiteSettings) {
                            if (in_array($altSiteSettings['siteId'], $groupSiteIds, false) && SiteHelper::siteEnabledWithUrls($altSiteSettings['siteId'])) {
                                $altElement = null;
                                if ($seoElement !== null) {
                                    /** @var Element $altElement */
                                    $altElement = $seoElement::sitemapAltElement(
                                        $metaBundle,
                                        $element->id,
                                        $altSiteSettings['siteId']
                                    );
                                }
                                // Make sure to only include the `hreflang` if the element exists,
                                // and sitemaps are on for it
                                if (Seomatic::$settings->addHrefLang && $altElement && $altElement->url) {
                                    list($altSourceId, $altSourceBundleType, $altSourceHandle, $altSourceSiteId, $altTypeId)
                                        = Seomatic::$plugin->metaBundles->getMetaSourceFromElement($altElement);
                                    $altMetaBundle = Seomatic::$plugin->metaBundles->getMetaBundleBySourceId(
                                        $altSourceBundleType,
                                        $altSourceId,
                                        $altSourceSiteId
                                    );
                                    if ($altMetaBundle) {
                                        $altEnabled = true;
                                        if (Seomatic::$craft34) {
                                            $altEnabled = $altElement->getEnabledForSite($altMetaBundle->sourceSiteId);
                                        }
                                        // Make sure this entry isn't disabled
                                        self::combineFieldSettings($altElement, $altMetaBundle);
                                        if ($altEnabled && $altMetaBundle->metaSitemapVars->sitemapUrls) {
                                            try {
                                                $altUrl = UrlHelper::siteUrl($altElement->url, null, null, $altSourceId);

It seems like $altElement->url can also be of type craft\base\ElementInterface[]; however, parameter $path of nystudio107\seomatic\helpers\UrlHelper::siteUrl() does only seem to accept string, maybe add an additional type check?

                                            } catch (Exception $e) {
                                                $altUrl = $altElement->url;
                                            }
                                            $altUrl = UrlHelper::absoluteUrlWithProtocol($altUrl);

It seems like $altUrl can also be of type craft\base\ElementInterface[]; however, parameter $url of nystudio107\seomatic\helpers\UrlHelper::absoluteUrlWithProtocol() does only seem to accept string, maybe add an additional type check?

                                            // If this is the primary site, add it as x-default, too
                                            if ($primarySiteId === $altSourceSiteId && Seomatic::$settings->addXDefaultHrefLang) {
                                                $lines[] = '<xhtml:link rel="alternate"'
                                                    . ' hreflang="x-default"'
                                                    . ' href="' . Html::encode($altUrl) . '"'
                                                    . ' />';
                                            }
                                            $lines[] = '<xhtml:link rel="alternate"'
                                                . ' hreflang="' . $altSiteSettings['language'] . '"'
                                                . ' href="' . Html::encode($altUrl) . '"'
                                                . ' />';
                                        }
                                    }
                                }
                            }
                        }
                    }
                    // Handle news sitemaps https://developers.google.com/search/docs/crawling-indexing/sitemaps/news-sitemap
                    if ((bool)$metaBundle->metaSitemapVars->newsSitemap) {
                        $now = new DateTime();
                        $interval = $now->diff($dateUpdated);
                        if ($interval->days <= 2) {
                            $language = strtolower($element->getLanguage());
                            if (!str_starts_with($language, 'zh')) {
                                $language = substr($language, 0, 2);
                            }
                            $lines[] = '<news:news>';
                            $lines[] = '<news:publication>';
                            $lines[] = '<news:name>' . $metaBundle->metaSitemapVars->newsPublicationName . '</news:name>';
                            $lines[] = '<news:language>' . $language . '</news:language>';
                            $lines[] = '</news:publication>';
                            $lines[] = '<news:publication_date>' . $dateUpdated->format(DateTime::W3C) . '</news:publication_date>';
                            $lines[] = '<news:title>' . $element->title . '</news:title>';
                            $lines[] = '</news:news>';
                        }
                    }
                    // Handle any Assets
                    if ($metaBundle->metaSitemapVars->sitemapAssets) {
                        // Regular Assets fields
                        $assetFields = FieldHelper::fieldsOfTypeFromElement(
                            $element,
                            FieldHelper::ASSET_FIELD_CLASS_KEY,
                            true
                        );
                        foreach ($assetFields as $assetField) {
                            $assets = $element[$assetField]->all();
                            /** @var Asset[] $assets */
                            foreach ($assets as $asset) {
                                self::assetSitemapItem($asset, $metaBundle, $lines);
                            }
                        }
                        // Assets embeded in Block fields
                        $blockFields = FieldHelper::fieldsOfTypeFromElement(
                            $element,
                            FieldHelper::BLOCK_FIELD_CLASS_KEY,
                            true
                        );
                        foreach ($blockFields as $blockField) {
                            $blocks = $element[$blockField]->all();
                            /** @var MatrixBlock[]|NeoBlock[]|SuperTableBlock[]|object[] $blocks */
                            foreach ($blocks as $block) {
                                $assetFields = [];
                                if ($block instanceof MatrixBlock) {
                                    $assetFields = FieldHelper::matrixFieldsOfType($block, AssetsField::class);
                                }
                                if ($block instanceof NeoBlock) {
                                    $assetFields = FieldHelper::neoFieldsOfType($block, AssetsField::class);
                                }
                                if ($block instanceof SuperTableBlock) {
                                    $assetFields = FieldHelper::superTableFieldsOfType($block, AssetsField::class);
                                }
                                foreach ($assetFields as $assetField) {
                                    foreach ($block[$assetField]->all() as $asset) {
                                        self::assetSitemapItem($asset, $metaBundle, $lines);
                                    }
                                }
                            }
                        }
                    }
                    $lines[] = '</url>';
                }
                // Include links to any known file types in the assets fields
                if ($metaBundle->metaSitemapVars->sitemapFiles) {
                    // Regular Assets fields
                    $assetFields = FieldHelper::fieldsOfTypeFromElement(
                        $element,
                        FieldHelper::ASSET_FIELD_CLASS_KEY,
                        true
                    );
                    foreach ($assetFields as $assetField) {
                        $assets = $element[$assetField]->all();
                        foreach ($assets as $asset) {
                            self::assetFilesSitemapLink($asset, $metaBundle, $lines);
                        }
                    }
                    // Assets embeded in Block fields
                    $blockFields = FieldHelper::fieldsOfTypeFromElement(
                        $element,
                        FieldHelper::BLOCK_FIELD_CLASS_KEY,
                        true
                    );
                    foreach ($blockFields as $blockField) {
                        $blocks = $element[$blockField]->all();
                        /** @var MatrixBlock[]|NeoBlock[]|SuperTableBlock[]|object[] $blocks */
                        foreach ($blocks as $block) {
                            $assetFields = [];
                            if ($block instanceof MatrixBlock) {
                                $assetFields = FieldHelper::matrixFieldsOfType($block, AssetsField::class);
                            }
                            if ($block instanceof SuperTableBlock) {
                                $assetFields = FieldHelper::superTableFieldsOfType($block, AssetsField::class);
                            }
                            if ($block instanceof NeoBlock) {
                                $assetFields = FieldHelper::neoFieldsOfType($block, AssetsField::class);
                            }
                            foreach ($assetFields as $assetField) {
                                foreach ($block[$assetField]->all() as $asset) {
                                    self::assetFilesSitemapLink($asset, $metaBundle, $lines);
                                }
                            }
                        }
                    }
                }
                $currentElement++;
            }

            if ($pagedSitemap) {
                break;
            }

            if ($paginator->getCurrentPage() == $paginator->getTotalPages()) {
                break;
            }

            $paginator->currentPage++;
            $elements = $paginator->getPageResults();
        } while (!empty($elements));

        // Sitemap closing tag
        $lines[] = '</urlset>';

        return implode('', $lines);
    }