Redirects::findRedirectMatch() - Code Metrics - Inspection of "Added the ability to redirect based on **Path Only..." - nystudio107/craft-retour - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( a6ed4d...77e1ed )

by Andrew

created 2018-10-13 21:25 UTC

Redirects::findRedirectMatch() A

↳ Parent: Redirects

Complexity

Conditions	4
Paths	4

Size

Total Lines	28
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	15
dl	0
loc	28
rs	9.7666
c	0
b	0
f	0
cc	4
nc	4
nop	2

<?php
/**
 * Retour plugin for Craft CMS 3.x
 *
 * Retour allows you to intelligently redirect legacy URLs, so that you don't
 * lose SEO value when rebuilding & restructuring a website
 *
 * @link      https://nystudio107.com/
 * @copyright Copyright (c) 2018 nystudio107
 */

namespace nystudio107\retour\services;

use craft\base\Plugin;
use nystudio107\retour\Retour;
use nystudio107\retour\models\StaticRedirects as StaticRedirectsModel;

use Craft;
use craft\base\Component;
use craft\db\Query;
use craft\errors\SiteNotFoundException;
use craft\helpers\Db;
use craft\helpers\UrlHelper;

use yii\base\ExitException;
use yii\base\InvalidConfigException;
use yii\caching\TagDependency;
use yii\db\Exception;

/** @noinspection MissingPropertyAnnotationsInspection */

/**
 * @author    nystudio107
 * @package   Retour
 * @since     3.0.0
 */
class Redirects extends Component
{
    // Constants
    // =========================================================================

    const CACHE_KEY = 'retour_redirect_';

    const GLOBAL_REDIRECTS_CACHE_TAG = 'retour_redirects';

    // Protected Properties
    // =========================================================================

    /**
     * @var null|array
     */
    protected $cachedStaticRedirects;

    // Public Methods
    // =========================================================================

    /**
     * Handle 404s by looking for redirects
     */
    public function handle404()
    {
        Craft::info(
            Craft::t(
                'retour',
                'A 404 exception occurred'
            ),
            __METHOD__
        );
        $request = Craft::$app->getRequest();
        // We only want site requests that are not live preview or console requests
        if ($request->getIsSiteRequest() && !$request->getIsLivePreview() && !$request->getIsConsoleRequest()) {
            // See if we should redirect
            try {
                $fullUrl = urldecode($request->getAbsoluteUrl());
                $pathOnly = urldecode($request->getUrl());
            } catch (InvalidConfigException $e) {
                Craft::error(
                    $e->getMessage(),
                    __METHOD__
                );
                $pathOnly = '';
                $fullUrl = '';
            }
            // Strip the query string if `alwaysStripQueryString` is set
            if (Retour::$settings->alwaysStripQueryString) {
                $fullUrl = UrlHelper::stripQueryString($fullUrl);
                $pathOnly = UrlHelper::stripQueryString($pathOnly);
            }
            Craft::info(
                Craft::t(
                    'retour',
                    '404 full URL: {fullUrl}, 404 path only: {pathOnly}',
                    ['fullUrl' => $fullUrl, 'pathOnly' => $pathOnly]
                ),
                __METHOD__
            );
            // Redirect if we find a match, otherwise let Craft handle it
            $redirect = $this->findRedirectMatch($fullUrl, $pathOnly);
            if (!$this->doRedirect($fullUrl, $pathOnly, $redirect) && !Retour::$settings->alwaysStripQueryString) {
                // Try it again without the query string
                $fullUrl = UrlHelper::stripQueryString($fullUrl);
                $pathOnly = UrlHelper::stripQueryString($pathOnly);
                $redirect = $this->findRedirectMatch($fullUrl, $pathOnly);
                $this->doRedirect($fullUrl, $pathOnly, $redirect);
            }
            // Increment the stats
            Retour::$plugin->statistics->incrementStatistics($pathOnly, false);
        }
    }

    /**
     * Do the redirect
     *
     * @param string     $fullUrl
     * @param string     $pathOnly
     * @param null|array $redirect
     *
     * @return bool false if not redirected
     */
    public function doRedirect(string $fullUrl, string $pathOnly, $redirect): bool
    {
        $response = Craft::$app->getResponse();
        if ($redirect !== null) {
            // Figure out what type of source matching was done
            $redirectSrcMatch = $redirect['redirectSrcMatch'] ?? 'pathonly';
            switch ($redirectSrcMatch) {
                case 'pathonly':
                    $url = $pathOnly;
                    break;
                case 'fullurl':
                    $url = $fullUrl;
                    break;
                default:
                    $url = $pathOnly;
                    break;
            }
            $dest = $redirect['redirectDestUrl'];
            $status = $redirect['redirectHttpCode'];
            Craft::info(
                Craft::t(
                    'retour',
                    'Redirecting {url} to {dest} with status {status}',
                    ['url' => $url, 'dest' => $dest, 'status' => $status]
                ),
                __METHOD__
            );
            // Increment the stats
            Retour::$plugin->statistics->incrementStatistics($url, true);
            // Redirect the request away
            $response->redirect($dest, $status)->send();
            try {
                Craft::$app->end();
            } catch (ExitException $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }
        }

        return false;
    }

    /**
     * @param string $fullUrl
     * @param string $pathOnly
     *
     * @return array|null
     */
    public function findRedirectMatch(string $fullUrl, string $pathOnly)
    {
        // Try getting the full URL redirect from the cache
        $redirect = $this->getRedirectFromCache($fullUrl);
        if ($redirect) {
            $this->incrementRedirectHitCount($redirect);
            $this->saveRedirectToCache($fullUrl, $redirect);

            return $redirect;
        }

        // Try getting the path only redirect from the cache
        $redirect = $this->getRedirectFromCache($pathOnly);
        if ($redirect) {
            $this->incrementRedirectHitCount($redirect);
            $this->saveRedirectToCache($pathOnly, $redirect);

            return $redirect;
        }

        // Resolve static redirects
        $redirects = $this->getAllStaticRedirects();
        $redirect = $this->resolveRedirect($fullUrl, $pathOnly, $redirects);
        if ($redirect) {
            return $redirect;
        }

        return null;
    }

    /**
     * @param $url
     *
     * @return bool|array
     */
    public function getRedirectFromCache($url)
    {
        $cache = Craft::$app->getCache();
        $cacheKey = $this::CACHE_KEY.md5($url);
        $redirect = $cache->get($cacheKey);
        Craft::info(
            Craft::t(
                'retour',
                'Cached redirect hit for {url}',
                ['url' => $url]
            ),
            __METHOD__
        );

        return $redirect;
    }

    /**
     * @param  string $url
     * @param  array  $redirect
     */
    public function saveRedirectToCache($url, $redirect)
    {
        $cacheKey = $this::CACHE_KEY.md5($url);
        $cache = Craft::$app->getCache();
        // Get the current site id
        $sites = Craft::$app->getSites();
        try {
            $siteId = $sites->getCurrentSite()->id;
        } catch (SiteNotFoundException $e) {
            $siteId = 1;
        }
        // Create the dependency tags
        $dependency = new TagDependency([
            'tags' => [
                $this::GLOBAL_REDIRECTS_CACHE_TAG,
                $this::GLOBAL_REDIRECTS_CACHE_TAG.$siteId,
            ],
        ]);
        $cache->set($cacheKey, $redirect, Retour::$cacheDuration, $dependency);
        Craft::info(
            Craft::t(
                'retour',
                'Cached redirect saved for {url}',
                ['url' => $url]
            ),
            __METHOD__
        );
    }

    /**
     * @param string $fullUrl
     * @param string $pathOnly
     * @param array  $redirects
     *
     * @return array|null
     */
    public function resolveRedirect(string $fullUrl, string $pathOnly, array $redirects)
    {
        $result = null;
        foreach ($redirects as $redirect) {
            // Figure out what type of source matching to do
            $redirectSrcMatch = $redirect['redirectSrcMatch'] ?? 'pathonly';
            switch ($redirectSrcMatch) {
                case 'pathonly':
                    $url = $pathOnly;
                    break;
                case 'fullurl':
                    $url = $fullUrl;
                    break;
                default:
                    $url = $pathOnly;
                    break;
            }
            $redirectMatchType = $redirect['redirectMatchType'] ?? 'notfound';
            switch ($redirectMatchType) {
                // Do a straight up match
                case 'exactmatch':
                    if (strcasecmp($redirect['redirectSrcUrlParsed'], $url) === 0) {
                        $this->incrementRedirectHitCount($redirect);
                        $this->saveRedirectToCache($url, $redirect);

                        return $redirect;
                    }
                    break;

                // Do a regex match
                case 'regexmatch':
                    $matchRegEx = '`'.$redirect['redirectSrcUrlParsed'].'`i';
                    if (preg_match($matchRegEx, $url) === 1) {
                        $this->incrementRedirectHitCount($redirect);
                        // If we're not associated with an EntryID, handle capture group replacement
                        if ((int)$redirect['associatedElementId'] === 0) {
                            $redirect['redirectDestUrl'] = preg_replace(
                                $matchRegEx,
                                $redirect['redirectDestUrl'],
                                $url
                            );
                        }
                        $this->saveRedirectToCache($url, $redirect);

                        return $redirect;
                    }
                    break;

                // Otherwise try to look up a plugin's method by and call it for the match
                default:
                    $plugin = $redirectMatchType ? Craft::$app->getPlugins()->getPlugin($redirectMatchType) : null;
                    if ($plugin && method_exists($plugin, 'retourMatch')) {
                        $args = [
                            [
                                'redirect' => &$redirect,
                            ],
                        ];
                        $result = \call_user_func_array([$plugin, 'retourMatch'], $args);
                        if ($result) {
                            $this->incrementRedirectHitCount($redirect);
                            $this->saveRedirectToCache($url, $redirect);

                            return $redirect;
                        }
                    }
                    break;
            }
        }
        Craft::info(
            Craft::t(
                'retour',
                'Not handled-> full URL: {fullUrl}, path only: {pathOnly}',
                ['fullUrl' => $fullUrl, 'pathOnly' => $pathOnly]
            ),
            __METHOD__
        );

        return $result;
    }

    /**
     * Returns the list of matching schemes
     *
     * @return  array
     */
    public function getMatchesList(): array
    {
        $result = [
            'exactmatch' => Craft::t('retour', 'Exact Match'),
            'regexmatch' => Craft::t('retour', 'RegEx Match'),
        ];

        // Add any plugins that offer the retourMatch() method
        foreach (Craft::$app->getPlugins()->getAllPlugins() as $plugin) {
            /** @var Plugin $plugin */
            if (method_exists($plugin, 'retourMatch')) {
                $result[$plugin->getHandle()] = $plugin->name.Craft::t('retour', ' Match');
            }
        }

        return $result;
    }

    /**
     * @param null|int $limit
     *
     * @return array All of the statistics
     */
    public function getAllStaticRedirects($limit = null): array
    {
        // Cache it in our class; no need to fetch it more than once
        if ($this->cachedStaticRedirects !== null) {
            return $this->cachedStaticRedirects;
        }
        // Query the db table
        $query = (new Query())
            ->from(['{{%retour_static_redirects}}'])
            ->orderBy('redirectMatchType ASC, hitCount DESC');
        if ($limit) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $query->limit($limit);
        }
        $redirects = $query->all();
        // Cache for future accesses
        $this->cachedStaticRedirects = $redirects;

        return $redirects;
    }

    /**
     * Return a redirect by id
     *
     * @param int $id
     *
     * @return null|array The static redirect
     */
    public function getRedirectById(int $id)
    {
        // Query the db table
        $redirect = (new Query())
            ->from(['{{%retour_static_redirects}}'])
            ->where(['id' => $id])
            ->one();

        return $redirect;
    }

    /**
     * Return a redirect by redirectSrcUrl
     *
     * @param string $redirectSrcUrl
     *
     * @return null|array
     */
    public function getRedirectByRedirectSrcUrl(string $redirectSrcUrl)
    {
        // Query the db table
        $redirect = (new Query())
            ->from(['{{%retour_static_redirects}}'])
            ->where(['redirectSrcUrl' => $redirectSrcUrl])
            ->one();

        return $redirect;
    }

    /**
     * Delete a redirect by id
     *
     * @param int $id
     *
     * @return int The result
     */
    public function deleteRedirectById(int $id): int
    {
        $db = Craft::$app->getDb();
        // Delete a row from the db table
        try {
            $result = $db->createCommand()->delete(
                '{{%retour_static_redirects}}',
                [
                    'id' => $id,
                ]
            )->execute();
        } catch (Exception $e) {
            Craft::error($e->getMessage(), __METHOD__);
            $result = 0;
        }

        return $result;
    }

    /**
     * Increment the retour_static_redirects record
     *
     * @param $redirectConfig
     */
    public function incrementRedirectHitCount(&$redirectConfig)
    {
        if ($redirectConfig !== null) {
            $db = Craft::$app->getDb();
            $redirectConfig['hitCount']++;
            $redirectConfig['hitLastTime'] = Db::prepareDateForDb(new \DateTime());
            Craft::debug(
                Craft::t(
                    'retour',
                    'Incrementing statistics for: {redirect}',
                    ['redirect' => print_r($redirectConfig, true)]
                ),
                __METHOD__
            );
            // Update the existing record
            try {
                $rowsAffected = $db->createCommand()->update(
                    '{{%retour_static_redirects}}',
                    [
                        'hitCount' => $redirectConfig['hitCount'],
                        'hitLastTime' => $redirectConfig['hitLastTime'],
                    ],
                    [
                        'id' => $redirectConfig['id'],
                    ]
                )->execute();
                Craft::debug('Rows affected: '.$rowsAffected, __METHOD__);
            } catch (Exception $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }
        }
    }

    /**
     * @param array $redirectConfig
     */
    public function saveRedirect(array $redirectConfig)
    {
        // Validate the model before saving it to the db
        $redirect = new StaticRedirectsModel($redirectConfig);
        if ($redirect->validate() === false) {
            Craft::error(
                Craft::t(
                    'retour',
                    'Error validating redirect {id}: {errors}',
                    ['id' => $redirect->id, 'errors' => print_r($redirect->getErrors(), true)]
                ),
                __METHOD__
            );

            return;
        }
        // Get the validated model attributes and save them to the db
        $redirectConfig = $redirect->getAttributes();
        $db = Craft::$app->getDb();
        // See if a redirect exists with this source URL already
        if ((int)$redirectConfig['id'] === 0) {
            // Query the db table
            $redirect = (new Query())
                ->from(['{{%retour_static_redirects}}'])
                ->where(['redirectSrcUrlParsed' => $redirectConfig['redirectSrcUrlParsed']])
                ->one();
            // If it exists, update it rather than having duplicates
            if (!empty($redirect)) {
                $redirectConfig['id'] = $redirect['id'];
            }
        }
        if ((int)$redirectConfig['id'] !== 0) {
            Craft::debug(
                Craft::t(
                    'retour',
                    'Updating existing redirect: {redirect}',
                    ['redirect' => print_r($redirectConfig, true)]
                ),
                __METHOD__
            );
            // Update the existing record
            try {
                $db->createCommand()->update(
                    '{{%retour_static_redirects}}',
                    $redirectConfig,
                    [
                        'id' => $redirectConfig['id'],
                    ]
                )->execute();
            } catch (Exception $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }
        } else {
            Craft::debug(
                Craft::t(
                    'retour',
                    'Creating new redirect: {redirect}',
                    ['redirect' => print_r($redirectConfig, true)]
                ),
                __METHOD__
            );
            unset($redirectConfig['id']);
            // Create a new record
            try {
                $db->createCommand()->insert(
                    '{{%retour_static_redirects}}',
                    $redirectConfig
                )->execute();
            } catch (Exception $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }
        }
        // To prevent redirect loops, see if any static redirects have our redirectDestUrl as their redirectSrcUrl
        $testRedirectConfig = $this->getRedirectByRedirectSrcUrl($redirectConfig['redirectDestUrl']);
        if ($testRedirectConfig !== null) {
            Craft::debug(
                Craft::t(
                    'retour',
                    'Deleting redirect to prevent a loop: {redirect}',
                    ['redirect' => print_r($testRedirectConfig, true)]
                ),
                __METHOD__
            );
            // Delete the redirect that has a redirectSrcUrl the same as this record's redirectDestUrl
            try {
                $db->createCommand()->delete(
                    '{{%retour_static_redirects}}',
                    ['id' => $testRedirectConfig['id']]
                )->execute();
            } catch (Exception $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }
        }
    }

    /**
     * Invalidate all of the redirects caches
     */
    public function invalidateCaches()
    {
        $cache = Craft::$app->getCache();
        TagDependency::invalidate($cache, $this::GLOBAL_REDIRECTS_CACHE_TAG);
        Craft::info(
            Craft::t(
                'retour',
                'All redirect caches cleared'
            ),
            __METHOD__
        );
    }
}


1			<?php
2			/**
3			* Retour plugin for Craft CMS 3.x
4			*
5			* Retour allows you to intelligently redirect legacy URLs, so that you don't
6			* lose SEO value when rebuilding & restructuring a website
7			*
8			* @link https://nystudio107.com/
9			* @copyright Copyright (c) 2018 nystudio107
10			*/
11
12			namespace nystudio107\retour\services;
13
14			use craft\base\Plugin;
15			use nystudio107\retour\Retour;
16			use nystudio107\retour\models\StaticRedirects as StaticRedirectsModel;
17
18			use Craft;
19			use craft\base\Component;
20			use craft\db\Query;
21			use craft\errors\SiteNotFoundException;
22			use craft\helpers\Db;
23			use craft\helpers\UrlHelper;
24
25			use yii\base\ExitException;
26			use yii\base\InvalidConfigException;
27			use yii\caching\TagDependency;
28			use yii\db\Exception;
29
30			/** @noinspection MissingPropertyAnnotationsInspection */
31
32			/**
33			* @author nystudio107
34			* @package Retour
35			* @since 3.0.0
36			*/
37			class Redirects extends Component
38			{
39			// Constants
40			// =========================================================================
41
42			const CACHE_KEY = 'retour_redirect_';
43
44			const GLOBAL_REDIRECTS_CACHE_TAG = 'retour_redirects';
45
46			// Protected Properties
47			// =========================================================================
48
49			/**
50			* @var null\|array
51			*/
52			protected $cachedStaticRedirects;
53
54			// Public Methods
55			// =========================================================================
56
57			/**
58			* Handle 404s by looking for redirects
59			*/
60			public function handle404()
61			{
62			Craft::info(
63			Craft::t(
64			'retour',
65			'A 404 exception occurred'
66			),
67			__METHOD__
68			);
69			$request = Craft::$app->getRequest();
70			// We only want site requests that are not live preview or console requests
71			if ($request->getIsSiteRequest() && !$request->getIsLivePreview() && !$request->getIsConsoleRequest()) {
72			// See if we should redirect
73			try {
74			$fullUrl = urldecode($request->getAbsoluteUrl());
75			$pathOnly = urldecode($request->getUrl());
76			} catch (InvalidConfigException $e) {
77			Craft::error(
78			$e->getMessage(),
79			__METHOD__
80			);
81			$pathOnly = '';
82			$fullUrl = '';
83			}
84			// Strip the query string if `alwaysStripQueryString` is set
85			if (Retour::$settings->alwaysStripQueryString) {
86			$fullUrl = UrlHelper::stripQueryString($fullUrl);
87			$pathOnly = UrlHelper::stripQueryString($pathOnly);
88			}
89			Craft::info(
90			Craft::t(
91			'retour',
92			'404 full URL: {fullUrl}, 404 path only: {pathOnly}',
93			['fullUrl' => $fullUrl, 'pathOnly' => $pathOnly]
94			),
95			__METHOD__
96			);
97			// Redirect if we find a match, otherwise let Craft handle it
98			$redirect = $this->findRedirectMatch($fullUrl, $pathOnly);
99			if (!$this->doRedirect($fullUrl, $pathOnly, $redirect) && !Retour::$settings->alwaysStripQueryString) {
100			// Try it again without the query string
101			$fullUrl = UrlHelper::stripQueryString($fullUrl);
102			$pathOnly = UrlHelper::stripQueryString($pathOnly);
103			$redirect = $this->findRedirectMatch($fullUrl, $pathOnly);
104			$this->doRedirect($fullUrl, $pathOnly, $redirect);
105			}
106			// Increment the stats
107			Retour::$plugin->statistics->incrementStatistics($pathOnly, false);
108			}
109			}
110
111			/**
112			* Do the redirect
113			*
114			* @param string $fullUrl
115			* @param string $pathOnly
116			* @param null\|array $redirect
117			*
118			* @return bool false if not redirected
119			*/
120			public function doRedirect(string $fullUrl, string $pathOnly, $redirect): bool
121			{
122			$response = Craft::$app->getResponse();
123			if ($redirect !== null) {
124			// Figure out what type of source matching was done
125			$redirectSrcMatch = $redirect['redirectSrcMatch'] ?? 'pathonly';
126			switch ($redirectSrcMatch) {
127			case 'pathonly':
128			$url = $pathOnly;
129			break;
130			case 'fullurl':
131			$url = $fullUrl;
132			break;
133			default:
134			$url = $pathOnly;
135			break;
136			}
137			$dest = $redirect['redirectDestUrl'];
138			$status = $redirect['redirectHttpCode'];
139			Craft::info(
140			Craft::t(
141			'retour',
142			'Redirecting {url} to {dest} with status {status}',
143			['url' => $url, 'dest' => $dest, 'status' => $status]
144			),
145			__METHOD__
146			);
147			// Increment the stats
148			Retour::$plugin->statistics->incrementStatistics($url, true);
149			// Redirect the request away
150			$response->redirect($dest, $status)->send();
151			try {
152			Craft::$app->end();
153			} catch (ExitException $e) {
154			Craft::error($e->getMessage(), __METHOD__);
155			}
156			}
157
158			return false;
159			}
160
161			/**
162			* @param string $fullUrl
163			* @param string $pathOnly
164			*
165			* @return array\|null
166			*/
167			public function findRedirectMatch(string $fullUrl, string $pathOnly)
168			{
169			// Try getting the full URL redirect from the cache
170			$redirect = $this->getRedirectFromCache($fullUrl);
171			if ($redirect) {
172			$this->incrementRedirectHitCount($redirect);
173			$this->saveRedirectToCache($fullUrl, $redirect);
174
175			return $redirect;
176			}
177
178			// Try getting the path only redirect from the cache
179			$redirect = $this->getRedirectFromCache($pathOnly);
180			if ($redirect) {
181			$this->incrementRedirectHitCount($redirect);
182			$this->saveRedirectToCache($pathOnly, $redirect);
183
184			return $redirect;
185			}
186
187			// Resolve static redirects
188			$redirects = $this->getAllStaticRedirects();
189			$redirect = $this->resolveRedirect($fullUrl, $pathOnly, $redirects);
190			if ($redirect) {
191			return $redirect;
192			}
193
194			return null;
195			}
196
197			/**
198			* @param $url
199			*
200			* @return bool\|array
201			*/
202			public function getRedirectFromCache($url)
203			{
204			$cache = Craft::$app->getCache();
205			$cacheKey = $this::CACHE_KEY.md5($url);
206			$redirect = $cache->get($cacheKey);
207			Craft::info(
208			Craft::t(
209			'retour',
210			'Cached redirect hit for {url}',
211			['url' => $url]
212			),
213			__METHOD__
214			);
215
216			return $redirect;
217			}
218
219			/**
220			* @param string $url
221			* @param array $redirect
222			*/
223			public function saveRedirectToCache($url, $redirect)
224			{
225			$cacheKey = $this::CACHE_KEY.md5($url);
226			$cache = Craft::$app->getCache();
227			// Get the current site id
228			$sites = Craft::$app->getSites();
229			try {
230			$siteId = $sites->getCurrentSite()->id;
231			} catch (SiteNotFoundException $e) {
232			$siteId = 1;
233			}
234			// Create the dependency tags
235			$dependency = new TagDependency([
236			'tags' => [
237			$this::GLOBAL_REDIRECTS_CACHE_TAG,
238			$this::GLOBAL_REDIRECTS_CACHE_TAG.$siteId,
239			],
240			]);
241			$cache->set($cacheKey, $redirect, Retour::$cacheDuration, $dependency);
242			Craft::info(
243			Craft::t(
244			'retour',
245			'Cached redirect saved for {url}',
246			['url' => $url]
247			),
248			__METHOD__
249			);
250			}
251
252			/**
253			* @param string $fullUrl
254			* @param string $pathOnly
255			* @param array $redirects
256			*
257			* @return array\|null
258			*/
259			public function resolveRedirect(string $fullUrl, string $pathOnly, array $redirects)
260			{
261			$result = null;
262			foreach ($redirects as $redirect) {
263			// Figure out what type of source matching to do
264			$redirectSrcMatch = $redirect['redirectSrcMatch'] ?? 'pathonly';
265			switch ($redirectSrcMatch) {
266			case 'pathonly':
267			$url = $pathOnly;
268			break;
269			case 'fullurl':
270			$url = $fullUrl;
271			break;
272			default:
273			$url = $pathOnly;
274			break;
275			}
276			$redirectMatchType = $redirect['redirectMatchType'] ?? 'notfound';
277			switch ($redirectMatchType) {
278			// Do a straight up match
279			case 'exactmatch':
280			if (strcasecmp($redirect['redirectSrcUrlParsed'], $url) === 0) {
281			$this->incrementRedirectHitCount($redirect);
282			$this->saveRedirectToCache($url, $redirect);
283
284			return $redirect;
285			}
286			break;
287
288			// Do a regex match
289			case 'regexmatch':
290			$matchRegEx = '`'.$redirect['redirectSrcUrlParsed'].'`i';
291			if (preg_match($matchRegEx, $url) === 1) {
292			$this->incrementRedirectHitCount($redirect);
293			// If we're not associated with an EntryID, handle capture group replacement
294			if ((int)$redirect['associatedElementId'] === 0) {
295			$redirect['redirectDestUrl'] = preg_replace(
296			$matchRegEx,
297			$redirect['redirectDestUrl'],
298			$url
299			);
300			}
301			$this->saveRedirectToCache($url, $redirect);
302
303			return $redirect;
304			}
305			break;
306
307			// Otherwise try to look up a plugin's method by and call it for the match
308			default:
309			$plugin = $redirectMatchType ? Craft::$app->getPlugins()->getPlugin($redirectMatchType) : null;
310			if ($plugin && method_exists($plugin, 'retourMatch')) {
311			$args = [
312			[
313			'redirect' => &$redirect,
314			],
315			];
316			$result = \call_user_func_array([$plugin, 'retourMatch'], $args);
317			if ($result) {
318			$this->incrementRedirectHitCount($redirect);
319			$this->saveRedirectToCache($url, $redirect);
320
321			return $redirect;
322			}
323			}
324			break;
325			}
326			}
327			Craft::info(
328			Craft::t(
329			'retour',
330			'Not handled-> full URL: {fullUrl}, path only: {pathOnly}',
331			['fullUrl' => $fullUrl, 'pathOnly' => $pathOnly]
332			),
333			__METHOD__
334			);
335
336			return $result;
337			}
338
339			/**
340			* Returns the list of matching schemes
341			*
342			* @return array
343			*/
344			public function getMatchesList(): array
345			{
346			$result = [
347			'exactmatch' => Craft::t('retour', 'Exact Match'),
348			'regexmatch' => Craft::t('retour', 'RegEx Match'),
349			];
350
351			// Add any plugins that offer the retourMatch() method
352			foreach (Craft::$app->getPlugins()->getAllPlugins() as $plugin) {
353			/** @var Plugin $plugin */
354			if (method_exists($plugin, 'retourMatch')) {
355			$result[$plugin->getHandle()] = $plugin->name.Craft::t('retour', ' Match');
356			}
357			}
358
359			return $result;
360			}
361
362			/**
363			* @param null\|int $limit
364			*
365			* @return array All of the statistics
366			*/
367			public function getAllStaticRedirects($limit = null): array
368			{
369			// Cache it in our class; no need to fetch it more than once
370			if ($this->cachedStaticRedirects !== null) {
371			return $this->cachedStaticRedirects;
372			}
373			// Query the db table
374			$query = (new Query())
375			->from(['{{%retour_static_redirects}}'])
376			->orderBy('redirectMatchType ASC, hitCount DESC');
377			if ($limit) {
			0 ignored issues – show Bug Best Practice introduced 2018-09-09 23:10 UTC by Report Bug Copy Issue Report The expression `$limit` of type `null\|integer` is loosely compared to `true`; this is ambiguous if the integer can be 0. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
378			$query->limit($limit);
379			}
380			$redirects = $query->all();
381			// Cache for future accesses
382			$this->cachedStaticRedirects = $redirects;
383
384			return $redirects;
385			}
386
387			/**
388			* Return a redirect by id
389			*
390			* @param int $id
391			*
392			* @return null\|array The static redirect
393			*/
394			public function getRedirectById(int $id)
395			{
396			// Query the db table
397			$redirect = (new Query())
398			->from(['{{%retour_static_redirects}}'])
399			->where(['id' => $id])
400			->one();
401
402			return $redirect;
403			}
404
405			/**
406			* Return a redirect by redirectSrcUrl
407			*
408			* @param string $redirectSrcUrl
409			*
410			* @return null\|array
411			*/
412			public function getRedirectByRedirectSrcUrl(string $redirectSrcUrl)
413			{
414			// Query the db table
415			$redirect = (new Query())
416			->from(['{{%retour_static_redirects}}'])
417			->where(['redirectSrcUrl' => $redirectSrcUrl])
418			->one();
419
420			return $redirect;
421			}
422
423			/**
424			* Delete a redirect by id
425			*
426			* @param int $id
427			*
428			* @return int The result
429			*/
430			public function deleteRedirectById(int $id): int
431			{
432			$db = Craft::$app->getDb();
433			// Delete a row from the db table
434			try {
435			$result = $db->createCommand()->delete(
436			'{{%retour_static_redirects}}',
437			[
438			'id' => $id,
439			]
440			)->execute();
441			} catch (Exception $e) {
442			Craft::error($e->getMessage(), __METHOD__);
443			$result = 0;
444			}
445
446			return $result;
447			}
448
449			/**
450			* Increment the retour_static_redirects record
451			*
452			* @param $redirectConfig
453			*/
454			public function incrementRedirectHitCount(&$redirectConfig)
455			{
456			if ($redirectConfig !== null) {
457			$db = Craft::$app->getDb();
458			$redirectConfig['hitCount']++;
459			$redirectConfig['hitLastTime'] = Db::prepareDateForDb(new \DateTime());
460			Craft::debug(
461			Craft::t(
462			'retour',
463			'Incrementing statistics for: {redirect}',
464			['redirect' => print_r($redirectConfig, true)]
465			),
466			__METHOD__
467			);
468			// Update the existing record
469			try {
470			$rowsAffected = $db->createCommand()->update(
471			'{{%retour_static_redirects}}',
472			[
473			'hitCount' => $redirectConfig['hitCount'],
474			'hitLastTime' => $redirectConfig['hitLastTime'],
475			],
476			[
477			'id' => $redirectConfig['id'],
478			]
479			)->execute();
480			Craft::debug('Rows affected: '.$rowsAffected, __METHOD__);
481			} catch (Exception $e) {
482			Craft::error($e->getMessage(), __METHOD__);
483			}
484			}
485			}
486
487			/**
488			* @param array $redirectConfig
489			*/
490			public function saveRedirect(array $redirectConfig)
491			{
492			// Validate the model before saving it to the db
493			$redirect = new StaticRedirectsModel($redirectConfig);
494			if ($redirect->validate() === false) {
495			Craft::error(
496			Craft::t(
497			'retour',
498			'Error validating redirect {id}: {errors}',
499			['id' => $redirect->id, 'errors' => print_r($redirect->getErrors(), true)]
500			),
501			__METHOD__
502			);
503
504			return;
505			}
506			// Get the validated model attributes and save them to the db
507			$redirectConfig = $redirect->getAttributes();
508			$db = Craft::$app->getDb();
509			// See if a redirect exists with this source URL already
510			if ((int)$redirectConfig['id'] === 0) {
511			// Query the db table
512			$redirect = (new Query())
513			->from(['{{%retour_static_redirects}}'])
514			->where(['redirectSrcUrlParsed' => $redirectConfig['redirectSrcUrlParsed']])
515			->one();
516			// If it exists, update it rather than having duplicates
517			if (!empty($redirect)) {
518			$redirectConfig['id'] = $redirect['id'];
519			}
520			}
521			if ((int)$redirectConfig['id'] !== 0) {
522			Craft::debug(
523			Craft::t(
524			'retour',
525			'Updating existing redirect: {redirect}',
526			['redirect' => print_r($redirectConfig, true)]
527			),
528			__METHOD__
529			);
530			// Update the existing record
531			try {
532			$db->createCommand()->update(
533			'{{%retour_static_redirects}}',
534			$redirectConfig,
535			[
536			'id' => $redirectConfig['id'],
537			]
538			)->execute();
539			} catch (Exception $e) {
540			Craft::error($e->getMessage(), __METHOD__);
541			}
542			} else {
543			Craft::debug(
544			Craft::t(
545			'retour',
546			'Creating new redirect: {redirect}',
547			['redirect' => print_r($redirectConfig, true)]
548			),
549			__METHOD__
550			);
551			unset($redirectConfig['id']);
552			// Create a new record
553			try {
554			$db->createCommand()->insert(
555			'{{%retour_static_redirects}}',
556			$redirectConfig
557			)->execute();
558			} catch (Exception $e) {
559			Craft::error($e->getMessage(), __METHOD__);
560			}
561			}
562			// To prevent redirect loops, see if any static redirects have our redirectDestUrl as their redirectSrcUrl
563			$testRedirectConfig = $this->getRedirectByRedirectSrcUrl($redirectConfig['redirectDestUrl']);
564			if ($testRedirectConfig !== null) {
565			Craft::debug(
566			Craft::t(
567			'retour',
568			'Deleting redirect to prevent a loop: {redirect}',
569			['redirect' => print_r($testRedirectConfig, true)]
570			),
571			__METHOD__
572			);
573			// Delete the redirect that has a redirectSrcUrl the same as this record's redirectDestUrl
574			try {
575			$db->createCommand()->delete(
576			'{{%retour_static_redirects}}',
577			['id' => $testRedirectConfig['id']]
578			)->execute();
579			} catch (Exception $e) {
580			Craft::error($e->getMessage(), __METHOD__);
581			}
582			}
583			}
584
585			/**
586			* Invalidate all of the redirects caches
587			*/
588			public function invalidateCaches()
589			{
590			$cache = Craft::$app->getCache();
591			TagDependency::invalidate($cache, $this::GLOBAL_REDIRECTS_CACHE_TAG);
592			Craft::info(
593			Craft::t(
594			'retour',
595			'All redirect caches cleared'
596			),
597			__METHOD__
598			);
599			}
600			}
601

nystudio107 / craft-retour

Push — develop ( a6ed4d...77e1ed )

Redirects::findRedirectMatch() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like