ImageOptimize::init() - Code Metrics - Inspection of "Refactor out to installEventHandlers" - nystudio107/craft-imageoptimize - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — develop (9dd105)

by Andrew

created 2018-03-18 16:49 UTC

ImageOptimize::init() A

↳ Parent: ImageOptimize

Complexity

Conditions	2
Paths	2

Size

Total Lines	22
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	22
rs	9.2
c	0
b	0
f	0
cc	2
eloc	14
nc	2
nop	0

<?php
/**
 * ImageOptimize plugin for Craft CMS 3.x
 *
 * Automatically optimize images after they've been transformed
 *
 * @link      https://nystudio107.com
 * @copyright Copyright (c) 2017 nystudio107
 */

namespace nystudio107\imageoptimize;

use nystudio107\imageoptimize\fields\OptimizedImages;
use nystudio107\imageoptimize\imagetransforms\ImageTransformInterface;
use nystudio107\imageoptimize\models\Settings;
use nystudio107\imageoptimize\services\Optimize as OptimizeService;
use nystudio107\imageoptimize\services\OptimizedImages as OptimizedImagesService;
use nystudio107\imageoptimize\services\Placeholder as PlaceholderService;
use nystudio107\imageoptimize\variables\ImageOptimizeVariable;

use Craft;
use craft\base\Element;
use craft\base\Field;
use craft\base\Plugin;
use craft\base\Volume;
use craft\console\Application as ConsoleApplication;
use craft\elements\Asset;
use craft\events\AssetTransformImageEvent;
use craft\events\ElementEvent;
use craft\events\FieldEvent;
use craft\events\GetAssetUrlEvent;
use craft\events\GenerateTransformEvent;
use craft\events\PluginEvent;
use craft\events\RegisterComponentTypesEvent;
use craft\events\ReplaceAssetEvent;
use craft\events\VolumeEvent;
use craft\helpers\UrlHelper;
use craft\models\FieldLayout;
use craft\services\Assets;
use craft\services\AssetTransforms;
use craft\services\Elements;
use craft\services\Fields;
use craft\services\Plugins;
use craft\services\Volumes;
use craft\web\twig\variables\CraftVariable;
use craft\web\Controller;

use yii\base\Event;

/** @noinspection MissingPropertyAnnotationsInspection */

/**
 * Class ImageOptimize
 *
 * @author    nystudio107
 * @package   ImageOptimize
 * @since     1.0.0
 *
 * @property OptimizeService        optimize
 * @property PlaceholderService     placeholder
 * @property OptimizedImagesService optimizedImages
 * @property Settings               $settings
 * @method   Settings               getSettings()
 */
class ImageOptimize extends Plugin
{
    // Static Properties
    // =========================================================================

    /**
     * @var ImageOptimize
     */
    public static $plugin;

    /**
     * @var ImageTransformInterface
     */
    public static $transformClass;

    /**
     * @var array
     */
    public static $transformParams;

    /**
     * @var bool
     */
    public static $generatePlacholders = true;

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

    /**
     * @inheritdoc
     */
    public function init()
    {
        parent::init();
        self::$plugin = $this;
        // Handle any console commands
        if (Craft::$app instanceof ConsoleApplication) {
            $this->controllerNamespace = 'nystudio107\imageoptimize\console\controllers';
        }
        // Cache some settings
        $settings = $this->getSettings();
        self::$transformClass = ImageTransformInterface::IMAGE_TRANSFORM_MAP[$settings->transformMethod];
        self::$transformParams = self::$transformClass::getTransformParams();
        // Install our global event handlers
        $this->installEventHandlers();
        // Log that the plugin has loaded
        Craft::info(
            Craft::t(
                'image-optimize',
                '{name} plugin loaded',
                ['name' => $this->name]
            ),
            __METHOD__
        );
    }

    /**
     * @inheritdoc
     */
    public function getSettingsResponse()
    {
        $view = Craft::$app->getView();
        $namespace = $view->getNamespace();
        $view->setNamespace('settings');
        $settingsHtml = $this->settingsHtml();
        $view->setNamespace($namespace);
        /** @var Controller $controller */
        $controller = Craft::$app->controller;

        return $controller->renderTemplate('image-optimize/_settings', [
            'plugin'       => $this,
            'settingsHtml' => $settingsHtml,
        ]);
    }

    /**
     * @inheritdoc
     */
    public function settingsHtml()
    {
        $imageProcessors = ImageOptimize::$plugin->optimize->getActiveImageProcessors();
        $variantCreators = ImageOptimize::$plugin->optimize->getActiveVariantCreators();
        // Get only the user-editable settings
        $settings = $this->getSettings();

        // Render the settings template
        return Craft::$app->getView()->renderTemplate(
            'image-optimize/settings',
            [
                'settings'        => $settings,
                'imageProcessors' => $imageProcessors,
                'variantCreators' => $variantCreators,
                'gdInstalled'  => function_exists('imagecreatefromjpeg'),
            ]
        );
    }

    // Protected Methods
    // =========================================================================

    /**
     * @inheritdoc
     */
    protected function createSettingsModel()
    {
        return new Settings();
    }

    /**
     * Install our event handlers
     */
    protected function installEventHandlers()
    {
        // Register our variables
        Event::on(
            CraftVariable::class,
            CraftVariable::EVENT_INIT,
            function (Event $event) {
                /** @var CraftVariable $variable */
                $variable = $event->sender;
                $variable->set('imageOptimize', ImageOptimizeVariable::class);
            }
        );

        // Register our Field
        Event::on(
            Fields::class,
            Fields::EVENT_REGISTER_FIELD_TYPES,
            function (RegisterComponentTypesEvent $event) {
                Craft::debug(
                    'Fields::EVENT_REGISTER_FIELD_TYPES',
                    __METHOD__
                );
                $event->types[] = OptimizedImages::class;
            }
        );

        // Handler: Fields::EVENT_AFTER_SAVE_FIELD
        Event::on(
            Fields::class,
            Fields::EVENT_AFTER_SAVE_FIELD,
            function (FieldEvent $event) {
                Craft::debug(
                    'Fields::EVENT_AFTER_SAVE_FIELD',
                    __METHOD__
                );
                $settings = $this->getSettings();
                /** @var Field $field */
                if (!$event->isNew && $settings->automaticallyResaveImageVariants) {
                    $thisField = $event->field;
                    if ($thisField instanceof OptimizedImages) {
                        $volumes = Craft::$app->getVolumes()->getAllVolumes();
                        foreach ($volumes as $volume) {
                            $needToReSave = false;
                            /** @var FieldLayout $fieldLayout */
                            /** @var Volume $volume */
                            $fieldLayout = $volume->getFieldLayout();
                            // Loop through the fields in the layout to see if it contains our field
                            if ($fieldLayout) {
                                $fields = $fieldLayout->getFields();
                                foreach ($fields as $field) {
                                    if ($thisField->handle == $field->handle) {
                                        $needToReSave = true;
                                    }
                                }
                                if ($needToReSave) {
                                    ImageOptimize::$plugin->optimizedImages->resaveVolumeAssets($volume);
                                }
                            }
                        }
                    }
                }
            }
        );

        // Handler: Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS
        Event::on(
            Plugins::class,
            Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS,
            function (PluginEvent $event) {
                if ($event->plugin === $this) {
                    Craft::debug(
                        'Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS',
                        __METHOD__
                    );
                    $settings = $this->getSettings();
                    if ($settings->automaticallyResaveImageVariants) {
                        // After they have changed the settings, resave all of the assets
                        ImageOptimize::$plugin->optimizedImages->resaveAllVolumesAssets();
                    }
                }
            }
        );

        // Handler: Volumes::EVENT_AFTER_SAVE_VOLUME
        Event::on(
            Volumes::class,
            Volumes::EVENT_AFTER_SAVE_VOLUME,
            function (VolumeEvent $event) {
                Craft::debug(
                    'Volumes::EVENT_AFTER_SAVE_VOLUME',
                    __METHOD__
                );
                $settings = $this->getSettings();
                // Only worry about this volume if it's not new
                if (!$event->isNew && $settings->automaticallyResaveImageVariants) {
                    /** @var Volume $volume */
                    $volume = $event->volume;
                    if (is_subclass_of($volume, Volume::class)) {
                        ImageOptimize::$plugin->optimizedImages->resaveVolumeAssets($volume);
                    }
                }
            }
        );

        // Handler: Assets::EVENT_GET_ASSET_URL
        Event::on(
            Assets::class,
            Assets::EVENT_GET_ASSET_URL,
            function (GetAssetUrlEvent $event) {
                Craft::debug(
                    'Assets::EVENT_GET_ASSET_URL',
                    __METHOD__
                );
                // Return the URL to the asset URL or null to let Craft handle it
                $event->url = ImageOptimize::$plugin->optimize->handleGetAssetUrlEvent(
                    $event
                );
            }
        );

        // Handler: AssetTransforms::EVENT_GENERATE_TRANSFORM
        Event::on(
            AssetTransforms::class,
            AssetTransforms::EVENT_GENERATE_TRANSFORM,
            function (GenerateTransformEvent $event) {
                Craft::debug(
                    'AssetTransforms::EVENT_GENERATE_TRANSFORM',
                    __METHOD__
                );
                // Return the path to the optimized image to _createTransformForAsset()
                $event->tempPath = ImageOptimize::$plugin->optimize->handleGenerateTransformEvent(
                    $event
                );
            }
        );

        // Handler: AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS
        Event::on(
            AssetTransforms::class,
            AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS,
            function (AssetTransformImageEvent $event) {
                Craft::debug(
                    'AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS',
                    __METHOD__
                );
                // Clean up any stray variant files
                ImageOptimize::$plugin->optimize->handleAfterDeleteTransformsEvent(
                    $event
                );
            }
        );

        // Handler: Elements::EVENT_BEFORE_SAVE_ELEMENT
        Event::on(
            Elements::class,
            Elements::EVENT_BEFORE_SAVE_ELEMENT,
            function (ElementEvent $event) {
                Craft::debug(
                    'Elements::EVENT_BEFORE_SAVE_ELEMENT',
                    __METHOD__
                );
                /** @var Element $element */
                $element = $event->element;
                $isNewElement = $event->isNew;
                if (($element instanceof Asset) && (!$isNewElement)) {
                    // Purge the URL
                    $purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
                        $element,
                        ImageOptimize::$transformParams
                    );
                    if ($purgeUrl) {
                        ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
                    }
                }
            }
        );

        // Handler: Elements::EVENT_BEFORE_DELETE_ELEMENT
        Event::on(
            Elements::class,
            Elements::EVENT_BEFORE_DELETE_ELEMENT,
            function (ElementEvent $event) {
                Craft::debug(
                    'Elements::EVENT_BEFORE_DELETE_ELEMENT',
                    __METHOD__
                );
                /** @var Element $element */
                $element = $event->element;
                if ($element instanceof Asset) {
                    // Purge the URL
                    $purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
                        $element,
                        ImageOptimize::$transformParams
                    );
                    if ($purgeUrl) {
                        ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
                    }
                }
            }
        );

        // Handler: Assets::EVENT_BEFORE_REPLACE_ASSET
        Event::on(
            Assets::class,
            Assets::EVENT_BEFORE_REPLACE_ASSET,
            function (ReplaceAssetEvent $event) {
                Craft::debug(
                    'Assets::EVENT_BEFORE_REPLACE_ASSET',
                    __METHOD__
                );
                /** @var Asset $element */
                $element = $event->asset;
                // Purge the URL
                $purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
                    $element,
                    ImageOptimize::$transformParams
                );
                if ($purgeUrl) {
                    ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
                }
            }
        );

        // Handler: Elements::EVENT_AFTER_REPLACE_ASSET
        Event::on(
            Assets::class,
            Assets::EVENT_AFTER_REPLACE_ASSET,
            function (ReplaceAssetEvent $event) {
                Craft::debug(
                    'Assets::EVENT_AFTER_REPLACE_ASSET',
                    __METHOD__
                );
                /** @var Asset $element */
                $element = $event->asset;
                if (!empty($element->id)) {
                    ImageOptimize::$plugin->optimizedImages->resaveAsset($element->id);
                }
            }
        );

        // Do something after we're installed
        Event::on(
            Plugins::class,
            Plugins::EVENT_AFTER_INSTALL_PLUGIN,
            function (PluginEvent $event) {
                if ($event->plugin === $this) {
                    $request = Craft::$app->getRequest();
                    if (($request->isCpRequest) && (!$request->isConsoleRequest)) {
                        Craft::$app->getResponse()->redirect(UrlHelper::cpUrl('image-optimize/welcome'))->send();
                    }
                }
            }
        );
    }
}


1			<?php
2			/**
3			* ImageOptimize plugin for Craft CMS 3.x
4			*
5			* Automatically optimize images after they've been transformed
6			*
7			* @link https://nystudio107.com
8			* @copyright Copyright (c) 2017 nystudio107
9			*/
10
11			namespace nystudio107\imageoptimize;
12
13			use nystudio107\imageoptimize\fields\OptimizedImages;
14			use nystudio107\imageoptimize\imagetransforms\ImageTransformInterface;
15			use nystudio107\imageoptimize\models\Settings;
16			use nystudio107\imageoptimize\services\Optimize as OptimizeService;
17			use nystudio107\imageoptimize\services\OptimizedImages as OptimizedImagesService;
18			use nystudio107\imageoptimize\services\Placeholder as PlaceholderService;
19			use nystudio107\imageoptimize\variables\ImageOptimizeVariable;
20
21			use Craft;
22			use craft\base\Element;
23			use craft\base\Field;
24			use craft\base\Plugin;
25			use craft\base\Volume;
26			use craft\console\Application as ConsoleApplication;
27			use craft\elements\Asset;
28			use craft\events\AssetTransformImageEvent;
29			use craft\events\ElementEvent;
30			use craft\events\FieldEvent;
31			use craft\events\GetAssetUrlEvent;
32			use craft\events\GenerateTransformEvent;
33			use craft\events\PluginEvent;
34			use craft\events\RegisterComponentTypesEvent;
35			use craft\events\ReplaceAssetEvent;
36			use craft\events\VolumeEvent;
37			use craft\helpers\UrlHelper;
38			use craft\models\FieldLayout;
39			use craft\services\Assets;
40			use craft\services\AssetTransforms;
41			use craft\services\Elements;
42			use craft\services\Fields;
43			use craft\services\Plugins;
44			use craft\services\Volumes;
45			use craft\web\twig\variables\CraftVariable;
46			use craft\web\Controller;
47
48			use yii\base\Event;
49
50			/** @noinspection MissingPropertyAnnotationsInspection */
51
52			/**
53			* Class ImageOptimize
54			*
55			* @author nystudio107
56			* @package ImageOptimize
57			* @since 1.0.0
58			*
59			* @property OptimizeService optimize
60			* @property PlaceholderService placeholder
61			* @property OptimizedImagesService optimizedImages
62			* @property Settings $settings
63			* @method Settings getSettings()
64			*/
65			class ImageOptimize extends Plugin
66			{
67			// Static Properties
68			// =========================================================================
69
70			/**
71			* @var ImageOptimize
72			*/
73			public static $plugin;
74
75			/**
76			* @var ImageTransformInterface
77			*/
78			public static $transformClass;
79
80			/**
81			* @var array
82			*/
83			public static $transformParams;
84
85			/**
86			* @var bool
87			*/
88			public static $generatePlacholders = true;
89
90			// Public Methods
91			// =========================================================================
92
93			/**
94			* @inheritdoc
95			*/
96			public function init()
97			{
98			parent::init();
99			self::$plugin = $this;
100			// Handle any console commands
101			if (Craft::$app instanceof ConsoleApplication) {
102			$this->controllerNamespace = 'nystudio107\imageoptimize\console\controllers';
103			}
104			// Cache some settings
105			$settings = $this->getSettings();
106			self::$transformClass = ImageTransformInterface::IMAGE_TRANSFORM_MAP[$settings->transformMethod];
107			self::$transformParams = self::$transformClass::getTransformParams();
108			// Install our global event handlers
109			$this->installEventHandlers();
110			// Log that the plugin has loaded
111			Craft::info(
112			Craft::t(
113			'image-optimize',
114			'{name} plugin loaded',
115			['name' => $this->name]
116			),
117			__METHOD__
118			);
119			}
120
121			/**
122			* @inheritdoc
123			*/
124			public function getSettingsResponse()
125			{
126			$view = Craft::$app->getView();
127			$namespace = $view->getNamespace();
128			$view->setNamespace('settings');
129			$settingsHtml = $this->settingsHtml();
130			$view->setNamespace($namespace);
131			/** @var Controller $controller */
132			$controller = Craft::$app->controller;
133
134			return $controller->renderTemplate('image-optimize/_settings', [
135			'plugin' => $this,
136			'settingsHtml' => $settingsHtml,
137			]);
138			}
139
140			/**
141			* @inheritdoc
142			*/
143			public function settingsHtml()
144			{
145			$imageProcessors = ImageOptimize::$plugin->optimize->getActiveImageProcessors();
146			$variantCreators = ImageOptimize::$plugin->optimize->getActiveVariantCreators();
147			// Get only the user-editable settings
148			$settings = $this->getSettings();
149
150			// Render the settings template
151			return Craft::$app->getView()->renderTemplate(
152			'image-optimize/settings',
153			[
154			'settings' => $settings,
155			'imageProcessors' => $imageProcessors,
156			'variantCreators' => $variantCreators,
157			'gdInstalled' => function_exists('imagecreatefromjpeg'),
158			]
159			);
160			}
161
162			// Protected Methods
163			// =========================================================================
164
165			/**
166			* @inheritdoc
167			*/
168			protected function createSettingsModel()
169			{
170			return new Settings();
171			}
172
173			/**
174			* Install our event handlers
175			*/
176			protected function installEventHandlers()
177			{
178			// Register our variables
179			Event::on(
180			CraftVariable::class,
181			CraftVariable::EVENT_INIT,
182			function (Event $event) {
183			/** @var CraftVariable $variable */
184			$variable = $event->sender;
185			$variable->set('imageOptimize', ImageOptimizeVariable::class);
186			}
187			);
188
189			// Register our Field
190			Event::on(
191			Fields::class,
192			Fields::EVENT_REGISTER_FIELD_TYPES,
193			function (RegisterComponentTypesEvent $event) {
194			Craft::debug(
195			'Fields::EVENT_REGISTER_FIELD_TYPES',
196			__METHOD__
197			);
198			$event->types[] = OptimizedImages::class;
199			}
200			);
201
202			// Handler: Fields::EVENT_AFTER_SAVE_FIELD
203			Event::on(
204			Fields::class,
205			Fields::EVENT_AFTER_SAVE_FIELD,
206			function (FieldEvent $event) {
207			Craft::debug(
208			'Fields::EVENT_AFTER_SAVE_FIELD',
209			__METHOD__
210			);
211			$settings = $this->getSettings();
212			/** @var Field $field */
213			if (!$event->isNew && $settings->automaticallyResaveImageVariants) {
214			$thisField = $event->field;
215			if ($thisField instanceof OptimizedImages) {
216			$volumes = Craft::$app->getVolumes()->getAllVolumes();
217			foreach ($volumes as $volume) {
218			$needToReSave = false;
219			/** @var FieldLayout $fieldLayout */
220			/** @var Volume $volume */
221			$fieldLayout = $volume->getFieldLayout();
222			// Loop through the fields in the layout to see if it contains our field
223			if ($fieldLayout) {
224			$fields = $fieldLayout->getFields();
225			foreach ($fields as $field) {
226			if ($thisField->handle == $field->handle) {
227			$needToReSave = true;
228			}
229			}
230			if ($needToReSave) {
231			ImageOptimize::$plugin->optimizedImages->resaveVolumeAssets($volume);
232			}
233			}
234			}
235			}
236			}
237			}
238			);
239
240			// Handler: Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS
241			Event::on(
242			Plugins::class,
243			Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS,
244			function (PluginEvent $event) {
245			if ($event->plugin === $this) {
246			Craft::debug(
247			'Plugins::EVENT_AFTER_SAVE_PLUGIN_SETTINGS',
248			__METHOD__
249			);
250			$settings = $this->getSettings();
251			if ($settings->automaticallyResaveImageVariants) {
252			// After they have changed the settings, resave all of the assets
253			ImageOptimize::$plugin->optimizedImages->resaveAllVolumesAssets();
254			}
255			}
256			}
257			);
258
259			// Handler: Volumes::EVENT_AFTER_SAVE_VOLUME
260			Event::on(
261			Volumes::class,
262			Volumes::EVENT_AFTER_SAVE_VOLUME,
263			function (VolumeEvent $event) {
264			Craft::debug(
265			'Volumes::EVENT_AFTER_SAVE_VOLUME',
266			__METHOD__
267			);
268			$settings = $this->getSettings();
269			// Only worry about this volume if it's not new
270			if (!$event->isNew && $settings->automaticallyResaveImageVariants) {
271			/** @var Volume $volume */
272			$volume = $event->volume;
273			if (is_subclass_of($volume, Volume::class)) {
274			ImageOptimize::$plugin->optimizedImages->resaveVolumeAssets($volume);
275			}
276			}
277			}
278			);
279
280			// Handler: Assets::EVENT_GET_ASSET_URL
281			Event::on(
282			Assets::class,
283			Assets::EVENT_GET_ASSET_URL,
284			function (GetAssetUrlEvent $event) {
285			Craft::debug(
286			'Assets::EVENT_GET_ASSET_URL',
287			__METHOD__
288			);
289			// Return the URL to the asset URL or null to let Craft handle it
290			$event->url = ImageOptimize::$plugin->optimize->handleGetAssetUrlEvent(
291			$event
292			);
293			}
294			);
295
296			// Handler: AssetTransforms::EVENT_GENERATE_TRANSFORM
297			Event::on(
298			AssetTransforms::class,
299			AssetTransforms::EVENT_GENERATE_TRANSFORM,
300			function (GenerateTransformEvent $event) {
301			Craft::debug(
302			'AssetTransforms::EVENT_GENERATE_TRANSFORM',
303			__METHOD__
304			);
305			// Return the path to the optimized image to _createTransformForAsset()
306			$event->tempPath = ImageOptimize::$plugin->optimize->handleGenerateTransformEvent(
307			$event
308			);
309			}
310			);
311
312			// Handler: AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS
313			Event::on(
314			AssetTransforms::class,
315			AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS,
316			function (AssetTransformImageEvent $event) {
317			Craft::debug(
318			'AssetTransforms::EVENT_AFTER_DELETE_TRANSFORMS',
319			__METHOD__
320			);
321			// Clean up any stray variant files
322			ImageOptimize::$plugin->optimize->handleAfterDeleteTransformsEvent(
323			$event
324			);
325			}
326			);
327
328			// Handler: Elements::EVENT_BEFORE_SAVE_ELEMENT
329			Event::on(
330			Elements::class,
331			Elements::EVENT_BEFORE_SAVE_ELEMENT,
332			function (ElementEvent $event) {
333			Craft::debug(
334			'Elements::EVENT_BEFORE_SAVE_ELEMENT',
335			__METHOD__
336			);
337			/** @var Element $element */
338			$element = $event->element;
339			$isNewElement = $event->isNew;
340			if (($element instanceof Asset) && (!$isNewElement)) {
341			// Purge the URL
342			$purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
343			$element,
344			ImageOptimize::$transformParams
345			);
346			if ($purgeUrl) {
347			ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
348			}
349			}
350			}
351			);
352
353			// Handler: Elements::EVENT_BEFORE_DELETE_ELEMENT
354			Event::on(
355			Elements::class,
356			Elements::EVENT_BEFORE_DELETE_ELEMENT,
357			function (ElementEvent $event) {
358			Craft::debug(
359			'Elements::EVENT_BEFORE_DELETE_ELEMENT',
360			__METHOD__
361			);
362			/** @var Element $element */
363			$element = $event->element;
364			if ($element instanceof Asset) {
365			// Purge the URL
366			$purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
367			$element,
368			ImageOptimize::$transformParams
369			);
370			if ($purgeUrl) {
371			ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
372			}
373			}
374			}
375			);
376
377			// Handler: Assets::EVENT_BEFORE_REPLACE_ASSET
378			Event::on(
379			Assets::class,
380			Assets::EVENT_BEFORE_REPLACE_ASSET,
381			function (ReplaceAssetEvent $event) {
382			Craft::debug(
383			'Assets::EVENT_BEFORE_REPLACE_ASSET',
384			__METHOD__
385			);
386			/** @var Asset $element */
387			$element = $event->asset;
388			// Purge the URL
389			$purgeUrl = ImageOptimize::$transformClass::getPurgeUrl(
390			$element,
391			ImageOptimize::$transformParams
392			);
393			if ($purgeUrl) {
394			ImageOptimize::$transformClass::purgeUrl($purgeUrl, ImageOptimize::$transformParams);
395			}
396			}
397			);
398
399			// Handler: Elements::EVENT_AFTER_REPLACE_ASSET
400			Event::on(
401			Assets::class,
402			Assets::EVENT_AFTER_REPLACE_ASSET,
403			function (ReplaceAssetEvent $event) {
404			Craft::debug(
405			'Assets::EVENT_AFTER_REPLACE_ASSET',
406			__METHOD__
407			);
408			/** @var Asset $element */
409			$element = $event->asset;
410			if (!empty($element->id)) {
411			ImageOptimize::$plugin->optimizedImages->resaveAsset($element->id);
412			}
413			}
414			);
415
416			// Do something after we're installed
417			Event::on(
418			Plugins::class,
419			Plugins::EVENT_AFTER_INSTALL_PLUGIN,
420			function (PluginEvent $event) {
421			if ($event->plugin === $this) {
422			$request = Craft::$app->getRequest();
423			if (($request->isCpRequest) && (!$request->isConsoleRequest)) {
424			Craft::$app->getResponse()->redirect(UrlHelper::cpUrl('image-optimize/welcome'))->send();
425			}
426			}
427			}
428			);
429			}
430			}
431

nystudio107 / craft-imageoptimize

Branch — develop (9dd105)

ImageOptimize::init() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like