primo commit

plugins/system/osmylicensesmanager/library/Free/PluginHelper.php

@@ -0,0 +1,144 @@
+<?php
+/**
+ * @package   ShackExtensionSupport
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2024 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackExtensionSupport.
+ *
+ * ShackExtensionSupport is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackExtensionSupport is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackExtensionSupport.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\OSMyLicensesManager\Free;
+
+use Alledia\Framework\Joomla\Extension\Licensed;
+
+// phpcs:disable PSR1.Files.SideEffects
+defined('_JEXEC') or die();
+// phpcs:enable PSR1.Files.SideEffects
+
+/**
+ * PluginHelper class
+ */
+abstract class PluginHelper
+{
+    /**
+     * @var string
+     */
+    protected static $downloadBaseURL = 'https://deploy.ostraining.com/client/download/';
+
+    /**
+     * Update the license key on the plugin params
+     *
+     * @param ?string $licenseKeys
+     *
+     * @return bool
+     */
+    public static function updateLicenseKeys(?string $licenseKeys = ''): bool
+    {
+        $licenseKeys = PluginHelper::sanitizeKey($licenseKeys);
+
+        // Update the extension params
+        $extension = new Licensed('osmylicensesmanager', 'plugin', 'system');
+        $extension->params->set('license-keys', $licenseKeys);
+        $extension->storeParams();
+
+        return true;
+    }
+
+    /**
+     * Detects if the passed URL is our download URL, returning a boolean value.
+     *
+     * @param string $url
+     *
+     * @return bool
+     */
+    public static function isOurDownloadURL(string $url): bool
+    {
+        return preg_match('#^' . static::$downloadBaseURL . '#', $url) === 1;
+    }
+
+    /**
+     * Removes the license key from the URL and returns it.
+     *
+     * @param string $url
+     *
+     * @return string
+     */
+    public static function getURLWithoutLicenseKey(string $url): string
+    {
+        if (static::isOurDownloadURL($url)) {
+            $url = preg_replace('#^(' . static::$downloadBaseURL . '(free|pro|paid)/[^/]+/[^/]+).*$#i', '$1', $url);
+            $url .= '/';
+        }
+
+        return $url;
+    }
+
+    /**
+     * Sanitizes the license key, making sure we have only valid chars.
+     *
+     * @param string $key
+     *
+     * @return string
+     */
+    public static function sanitizeKey(string $key): string
+    {
+        return preg_replace('/[^a-z0-9,]/i', '', $key);
+    }
+
+    /**
+     * Appends the license key to the URL and returns it. We recognize the url
+     * for designated generic extensions using a default license key to allow
+     * legacy customers to download updates.
+     *
+     * @param string $url
+     * @param string $keys
+     *
+     * @return string
+     */
+    public static function appendLicenseKeyToURL(string $url, string $keys): string
+    {
+        if (static::isOurDownloadURL($url)) {
+            $url = PluginHelper::getURLWithoutLicenseKey($url);
+
+            $sanitizedKeys = static::sanitizeKey($keys);
+
+            if ($keys) {
+                $encodedKeys = base64_encode($sanitizedKeys);
+                $url         .= $encodedKeys;
+            }
+        }
+
+        return $url;
+    }
+
+    /**
+     * Detects the license type based on the URL. If no license is detected,
+     * returns false
+     *
+     * @param string $url
+     *
+     * @return ?string
+     */
+    public static function getLicenseTypeFromURL(string $url): ?string
+    {
+        if (preg_match('#^' . static::$downloadBaseURL . '(free|pro)/#', $url, $matches)) {
+            return $matches[1];
+        }
+
+        return null;
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/AutoLoader.php

@@ -0,0 +1,221 @@
+<?php
+/**
+ * @package   ShackInstaller
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2023 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackInstaller.
+ *
+ * ShackInstaller is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackInstaller is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackInstaller.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\Installer;
+
+defined('_JEXEC') or die();
+
+class AutoLoader
+{
+    /**
+     * Associative array where the key is a namespace prefix and the value
+     * is an array of base directories for classes in that namespace.
+     *
+     * @var array
+     */
+    protected static $prefixes = [];
+
+    /**
+     * Associative array of prefixes for loading specialized camelCase classes
+     * where Uppercase letters in the class name indicate directory structure
+     *
+     * @var array
+     */
+    protected static $camelPrefixes = [];
+
+    /**
+     * @var AutoLoader
+     */
+    protected static $instance = null;
+
+    /**
+     * @param string $method
+     */
+    protected static function registerLoader($method)
+    {
+        if (static::$instance === null) {
+            static::$instance = new static();
+        }
+
+        spl_autoload_register([static::$instance, $method]);
+    }
+
+    /**
+     * Register a psr4 namespace
+     *
+     * @param string $prefix  The namespace prefix.
+     * @param string $baseDir A base directory for class files in the
+     *                         namespace.
+     * @param ?bool   $prepend If true, prepend the base directory to the stack
+     *                         instead of appending it; this causes it to be searched first rather
+     *                         than last.
+     *
+     * @return void
+     */
+    public static function register(string $prefix, string $baseDir, ?bool $prepend = false)
+    {
+        if (count(self::$prefixes) == 0) {
+            static::registerLoader('loadClass');
+        }
+
+        // normalize namespace prefix
+        $prefix = trim($prefix, '\\') . '\\';
+
+        // normalize the base directory with a trailing separator
+        $baseDir = rtrim($baseDir, '\\/') . '/';
+
+        // initialise the namespace prefix array
+        if (empty(self::$prefixes[$prefix])) {
+            self::$prefixes[$prefix] = [];
+        }
+
+        // retain the base directory for the namespace prefix
+        if ($prepend) {
+            array_unshift(self::$prefixes[$prefix], $baseDir);
+        } else {
+            array_push(self::$prefixes[$prefix], $baseDir);
+        }
+    }
+
+    /**
+     * Loads the class file for a given class name.
+     *
+     * @param string $class The fully-qualified class name.
+     *
+     * @return ?string The mapped file name on success
+     */
+    protected function loadClass(string $class): ?string
+    {
+        $prefixes  = explode('\\', $class);
+        $className = '';
+        while ($prefixes) {
+            $className = array_pop($prefixes) . $className;
+            $prefix    = join('\\', $prefixes) . '\\';
+
+            if ($filePath = $this->loadMappedFile($prefix, $className)) {
+                return $filePath;
+            }
+
+            $className = '\\' . $className;
+        }
+
+        return null;
+    }
+
+    /**
+     * Load the mapped file for a namespace prefix and class.
+     *
+     * @param string $prefix    The namespace prefix.
+     * @param string $className The relative class name.
+     *
+     * @return ?string path that was loaded
+     */
+    protected function loadMappedFile(string $prefix, string $className): ?string
+    {
+        // are there any base directories for this namespace prefix?
+        if (isset(self::$prefixes[$prefix]) === false) {
+            return null;
+        }
+
+        // look through base directories for this namespace prefix
+        foreach (self::$prefixes[$prefix] as $baseDir) {
+            $path = $baseDir . str_replace('\\', '/', $className) . '.php';
+
+            if (is_file($path)) {
+                require_once $path;
+
+                return $path;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Register a base directory for classes organized using camelCase.
+     * Class names beginning with the prefix will be automatically loaded
+     * if there is a matching file in the directory tree starting with $baseDir.
+     * File names and directory names are all expected to be lower case.
+     *
+     * Example:
+     *
+     * $prefix = 'Simplerenew'
+     * $baseDir = '/library/joomla'
+     *
+     * A class name of: SimplerenewViewAdmin
+     * Would be in    : /library/joomla/view/admin.php
+     *
+     * This system is intended for situations where full name spacing is either
+     * unavailable or impractical due to integration with other systems.
+     *
+     * @param string $prefix
+     * @param string $baseDir
+     *
+     * @return void
+     * @throws \Exception
+     */
+    public static function registerCamelBase(string $prefix, string $baseDir)
+    {
+        if (!is_dir($baseDir)) {
+            throw new \Exception("Cannot register '{$prefix}'. The requested base directory does not exist!'");
+        }
+
+        if (count(self::$camelPrefixes) == 0) {
+            // Register function on first call
+            static::registerLoader('loadCamelClass');
+        }
+
+        if (empty(self::$camelPrefixes[$prefix])) {
+            self::$camelPrefixes[$prefix] = $baseDir;
+        }
+    }
+
+    /**
+     * Autoload a class using the camelCase structure
+     *
+     * @param string $class
+     *
+     * @return string
+     */
+    protected function loadCamelClass(string $class): ?string
+    {
+        if (!class_exists($class)) {
+            foreach (self::$camelPrefixes as $prefix => $baseDir) {
+                if (strpos($class, $prefix) === 0) {
+                    $parts = preg_split('/(?<=[a-z])(?=[A-Z])/x', substr($class, strlen($prefix)));
+
+                    $file     = strtolower(join('/', $parts));
+                    $filePath = $baseDir . '/' . $file . '.php';
+
+                    if (is_file($filePath)) {
+                        require_once $filePath;
+
+                        return $filePath;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/Extension/Generic.php

@@ -0,0 +1,435 @@
+<?php
+/**
+ * @package   ShackInstaller
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2023 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackInstaller.
+ *
+ * ShackInstaller is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackInstaller is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackInstaller.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\Installer\Extension;
+
+defined('_JEXEC') or die();
+
+use Joomla\CMS\Factory;
+use Joomla\Registry\Registry;
+
+/**
+ * Generic extension class
+ */
+class Generic
+{
+    /**
+     * The extension namespace
+     *
+     * @var string
+     */
+    protected $namespace = null;
+
+    /**
+     * The extension type
+     *
+     * @var string
+     */
+    protected $type = null;
+
+    /**
+     * The extension id
+     *
+     * @var int
+     */
+    protected $id = null;
+
+    /**
+     * The extension name
+     *
+     * @var string
+     */
+    protected $name = null;
+
+    /**
+     * The extension params
+     *
+     * @var Registry
+     */
+    public $params = null;
+
+    /**
+     * The extension enable state
+     *
+     * @var bool
+     */
+    protected $enabled = null;
+
+    /**
+     * The element of the extension
+     *
+     * @var string
+     */
+    protected $element = null;
+
+    /**
+     * @var string
+     */
+    protected $folder = null;
+
+    /**
+     * Base path
+     *
+     * @var string
+     */
+    protected $basePath = null;
+
+    /**
+     * The manifest information
+     *
+     * @var \SimpleXMLElement
+     */
+    public $manifest = null;
+
+    /**
+     * The config.xml information
+     *
+     * @var \SimpleXMLElement
+     */
+    public $config = null;
+
+    /**
+     * Class constructor, set the extension type.
+     *
+     * @param string  $namespace The element of the extension
+     * @param string  $type      The type of extension
+     * @param ?string $folder    The folder for plugins (only)
+     * @param string  $basePath
+     *
+     * @return void
+     */
+    public function __construct(string $namespace, string $type, ?string $folder = '', string $basePath = JPATH_SITE)
+    {
+        $this->type      = $type;
+        $this->element   = strtolower($namespace);
+        $this->folder    = $folder;
+        $this->basePath  = $basePath;
+        $this->namespace = $namespace;
+
+        $this->getManifest();
+
+        $this->getDataFromDatabase();
+    }
+
+    /**
+     * Get information about this extension from the database
+     * NOTE: This is duplicated code from the corresponding class in
+     * \Alledia\Framework\Joomla\Extension\Generic
+     */
+    protected function getDataFromDatabase()
+    {
+        $element = $this->getElementToDb();
+
+        // Load the extension info from database
+        $db    = Factory::getDbo();
+        $query = $db->getQuery(true)
+            ->select([
+                $db->quoteName('extension_id'),
+                $db->quoteName('name'),
+                $db->quoteName('enabled'),
+                $db->quoteName('params')
+            ])
+            ->from('#__extensions')
+            ->where($db->quoteName('type') . ' = ' . $db->quote($this->type))
+            ->where($db->quoteName('element') . ' = ' . $db->quote($element));
+
+        if ($this->type === 'plugin') {
+            $query->where($db->quoteName('folder') . ' = ' . $db->quote($this->folder));
+        }
+
+        $db->setQuery($query);
+        $row = $db->loadObject();
+
+        if (is_object($row)) {
+            $this->id      = $row->extension_id;
+            $this->name    = $row->name;
+            $this->enabled = (bool)$row->enabled;
+            $this->params  = new Registry($row->params);
+
+        } else {
+            $this->id      = null;
+            $this->name    = null;
+            $this->enabled = false;
+            $this->params  = new Registry();
+
+        }
+    }
+
+    /**
+     * Check if the extension is enabled
+     *
+     * @return bool
+     */
+    public function isEnabled(): bool
+    {
+        return (bool)$this->enabled;
+    }
+
+    /**
+     * Get the path for the extension
+     *
+     * @return string The path
+     */
+    public function getExtensionPath(): string
+    {
+        $folders = [
+            'component' => 'administrator/components/',
+            'plugin'    => 'plugins/',
+            'template'  => 'templates/',
+            'library'   => 'libraries/',
+            'cli'       => 'cli/',
+            'module'    => 'modules/'
+        ];
+
+        $basePath = $this->basePath . '/' . $folders[$this->type];
+
+        switch ($this->type) {
+            case 'plugin':
+                $basePath .= $this->folder . '/';
+                break;
+
+            case 'module':
+                if (!preg_match('/^mod_/', $this->element)) {
+                    $basePath .= 'mod_';
+                }
+                break;
+
+            case 'component':
+                if (!preg_match('/^com_/', $this->element)) {
+                    $basePath .= 'com_';
+                }
+                break;
+        }
+
+        $basePath .= $this->element;
+
+        return $basePath;
+    }
+
+    /**
+     * Get the full element
+     *
+     * @return string
+     */
+    public function getFullElement(): string
+    {
+        $prefixes = [
+            'component' => 'com',
+            'plugin'    => 'plg',
+            'template'  => 'tpl',
+            'library'   => 'lib',
+            'cli'       => 'cli',
+            'module'    => 'mod'
+        ];
+
+        $fullElement = $prefixes[$this->type];
+
+        if ($this->type === 'plugin') {
+            $fullElement .= '_' . $this->folder;
+        }
+
+        $fullElement .= '_' . $this->element;
+
+        return $fullElement;
+    }
+
+    /**
+     * Get the element to match the database records.
+     * Only components and modules have the prefix.
+     *
+     * @return string The element
+     */
+    public function getElementToDb(): string
+    {
+        $prefixes = [
+            'component' => 'com_',
+            'module'    => 'mod_'
+        ];
+
+        $fullElement = '';
+        if (array_key_exists($this->type, $prefixes)) {
+            if (!preg_match('/^' . $prefixes[$this->type] . '/', $this->element)) {
+                $fullElement = $prefixes[$this->type];
+            }
+        }
+
+        $fullElement .= $this->element;
+
+        return $fullElement;
+    }
+
+    /**
+     * Get manifest path for this extension
+     *
+     * @return string
+     */
+    public function getManifestPath(): string
+    {
+        $extensionPath = $this->getExtensionPath();
+
+        switch ($this->type) {
+            case 'template':
+                $fileName = 'templateDetails.xml';
+                break;
+
+            case 'library':
+                $fileName = $this->element . '.xml';
+                if (!is_file($extensionPath . '/' . $fileName)) {
+                    $extensionPath = JPATH_MANIFESTS . '/libraries';
+                }
+                break;
+
+            case 'module':
+                $fileName = 'mod_' . $this->element . '.xml';
+                break;
+
+            case 'pkg':
+                $extensionPath = JPATH_MANIFESTS . '/packages';
+                $fileName      = 'pkg_' . $this->element . '.xml';
+                break;
+
+            case 'file':
+                $extensionPath = JPATH_MANIFESTS . '/files';
+                $fileName = 'file_' . $this->element . '.xml';
+                break;
+
+            default:
+                $fileName = $this->element . '.xml';
+                break;
+        }
+
+        return $extensionPath . '/' . $fileName;
+    }
+
+    /**
+     * Get extension information
+     *
+     * @param bool $force If true, force to load the manifest, ignoring the cached one
+     *
+     * @return ?\SimpleXMLElement
+     */
+    public function getManifest(bool $force = false): ?\SimpleXMLElement
+    {
+        if ($this->manifest === null || $force) {
+            $this->manifest = false;
+
+            $path = $this->getManifestPath();
+            if (is_file($path)) {
+                $this->manifest = simplexml_load_file($path);
+            }
+        }
+
+        return $this->manifest ?: null;
+    }
+
+    /**
+     * Get extension config file
+     *
+     * @param bool $force Force to reload the config file
+     *
+     * @return \SimpleXMLElement
+     */
+    public function getConfig(bool $force = false)
+    {
+        if ($this->config === null || $force) {
+            $path = $this->getExtensionPath() . '/config.xml';
+
+            $this->config = is_file($path) ? simplexml_load_file($path) : false;
+        }
+
+        return $this->config;
+    }
+
+    /**
+     * Returns the update URL from database
+     *
+     * @return string
+     */
+    public function getUpdateURL(): string
+    {
+        $db    = Factory::getDbo();
+        $query = $db->getQuery(true)
+            ->select('sites.location')
+            ->from('#__update_sites AS sites')
+            ->leftJoin('#__update_sites_extensions AS extensions ON (sites.update_site_id = extensions.update_site_id)')
+            ->where('extensions.extension_id = ' . $this->id);
+
+        return $db->setQuery($query)->loadResult();
+    }
+
+    /**
+     * Set the update URL
+     *
+     * @param string $url
+     */
+    public function setUpdateURL(string $url)
+    {
+        $db = Factory::getDbo();
+
+        // Get the update site id
+        $join  = $db->quoteName('#__update_sites_extensions') . ' AS extensions '
+            . 'ON (sites.update_site_id = extensions.update_site_id)';
+        $query = $db->getQuery(true)
+            ->select('sites.update_site_id')
+            ->from($db->quoteName('#__update_sites') . ' AS sites')
+            ->leftJoin($join)
+            ->where('extensions.extension_id = ' . $this->id);
+        $db->setQuery($query);
+        $siteId = (int)$db->loadResult();
+
+        if (!empty($siteId)) {
+            $query = $db->getQuery(true)
+                ->update($db->quoteName('#__update_sites'))
+                ->set($db->quoteName('location') . ' = ' . $db->quote($url))
+                ->where($db->quoteName('update_site_id') . ' = ' . $siteId);
+            $db->setQuery($query);
+            $db->execute();
+        }
+    }
+
+    /**
+     * Store the params on the database
+     *
+     * @return void
+     */
+    public function storeParams()
+    {
+        $db     = Factory::getDbo();
+        $params = $db->quote($this->params->toString());
+        $id     = $db->quote($this->id);
+
+        $query = "UPDATE `#__extensions` SET params = {$params} WHERE extension_id = {$id}";
+        $db->setQuery($query);
+        $db->execute();
+    }
+
+    /**
+     * Get extension name
+     *
+     * @return string
+     */
+    public function getName(): string
+    {
+        return $this->name;
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/Extension/Licensed.php

@@ -0,0 +1,147 @@
+<?php
+/**
+ * @package   ShackInstaller
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2023 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackInstaller.
+ *
+ * ShackInstaller is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackInstaller is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackInstaller.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\Installer\Extension;
+
+defined('_JEXEC') or die();
+
+use Alledia\Installer\AutoLoader;
+
+/**
+ * Licensed class, for extensions with Free and Pro versions
+ */
+class Licensed extends Generic
+{
+    /**
+     * License type: free or pro
+     *
+     * @var string
+     */
+    protected $license = null;
+
+    /**
+     * The path for the pro library
+     *
+     * @var string
+     */
+    protected $proLibraryPath = null;
+
+    /**
+     * The path for the free library
+     *
+     * @var string
+     */
+    protected $libraryPath = null;
+
+    /**
+     * @inheritDoc
+     */
+    public function __construct(string $namespace, string $type, ?string $folder = '', string $basePath = JPATH_SITE)
+    {
+        parent::__construct($namespace, $type, $folder, $basePath);
+
+        $this->license = $this->manifest ? strtolower($this->manifest->alledia->license) : 'free';
+
+        $this->getLibraryPath();
+        $this->getProLibraryPath();
+    }
+
+    /**
+     * Check if the license is pro
+     *
+     * @return bool True for pro license
+     */
+    public function isPro(): bool
+    {
+        return $this->license === 'pro';
+    }
+
+    /**
+     * Check if the license is free
+     *
+     * @return bool
+     */
+    public function isFree(): bool
+    {
+        return !$this->isPro();
+    }
+
+    /**
+     * Get the path for the free library, based on the extension type
+     *
+     * @return string The path for pro
+     */
+    public function getLibraryPath(): string
+    {
+        if (empty($this->libraryPath)) {
+            $basePath = $this->getExtensionPath();
+
+            $this->libraryPath = $basePath . '/library';
+        }
+
+        return $this->libraryPath;
+    }
+
+    /**
+     * Get path for the pro library, based on the extension type
+     *
+     * @return string The path for pro
+     */
+    public function getProLibraryPath(): string
+    {
+        if ($this->proLibraryPath === null) {
+            $basePath = $this->getLibraryPath();
+
+            $this->proLibraryPath = $basePath . '/Pro';
+        }
+
+        return $this->proLibraryPath;
+    }
+
+    /**
+     * Loads the library, if existent (including the Pro Library)
+     *
+     * @return bool
+     * @throws \Exception
+     */
+    public function loadLibrary(): bool
+    {
+        $libraryPath = $this->getLibraryPath();
+
+        // If we have a library path, lets load it
+        if (is_dir($libraryPath)) {
+            if ($this->isPro()) {
+                // Check if the pro library exists
+                if (!is_dir($this->getProLibraryPath())) {
+                    throw new \Exception("Pro library not found: {$this->type}, {$this->element}");
+                }
+            }
+
+            AutoLoader::register('Alledia\\' . $this->namespace, $libraryPath);
+
+            return true;
+        }
+
+        return false;
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/Loader.php

@@ -0,0 +1,101 @@
+<?php
+/**
+ * @package   ShackInstaller
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2023 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackInstaller.
+ *
+ * ShackInstaller is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackInstaller is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackInstaller.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\Installer;
+
+use Alledia\Framework\Factory;
+use Joomla\CMS\Log\Log;
+
+defined('_JEXEC') or die();
+
+abstract class Loader
+{
+    protected static $logRegistered = false;
+
+    /**
+     * Safely include a PHP file, making sure it exists before import.
+     *
+     * This method will register a log message and display a warning for admins
+     * in case the file is missed.
+     *
+     * @param string $path The file path you want to include
+     *
+     * @return  bool
+     * @throws \Exception
+     */
+    public static function includeFile(string $path): bool
+    {
+        if (!static::$logRegistered) {
+            Log::addLogger(
+                ['text_file' => 'shackframework.loader.errors.php'],
+                Log::ALL,
+                ['allediaframework']
+            );
+
+            static::$logRegistered = true;
+        }
+
+        // Check if the file doesn't exist
+        if (!is_file($path)) {
+            $logMsg = 'Required file is missed: ' . $path;
+
+            // Generate a backtrace to know from where the request cames
+            if (version_compare(phpversion(), '5.4', '<')) {
+                $backtrace = debug_backtrace();
+            } else {
+                $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+            }
+
+            if (!empty($backtrace)) {
+                $logMsg .= sprintf(
+                    ' (%s:%s)',
+                    $backtrace[0]['file'],
+                    $backtrace[0]['line']
+                );
+            }
+
+            // Register the log
+            Log::add($logMsg, Log::ERROR, 'allediaframework');
+
+            // Warn admin users
+            $app = Factory::getApplication();
+            if ($app->getName() == 'administrator') {
+                $app->enqueueMessage(
+                    'ShackInstaller Loader detected that a required file was not found! Please, check the logs.',
+                    'error'
+                );
+            }
+
+            // Stand up a flag to warn a required file is missed
+            if (!defined('SHACK_INSTALLER_MISSED_FILE')) {
+                define('SHACK_INSTALLER_MISSED_FILE', true);
+            }
+
+            return false;
+        }
+
+        include_once $path;
+
+        return true;
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/TraitInstallerCheck.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * @package   OSEmbed
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2020-2021 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of OSEmbed.
+ *
+ * OSEmbed is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * OSEmbed is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OSEmbed.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+namespace Alledia\Installer;
+
+use Joomla\CMS\Factory;
+use Joomla\CMS\Installer\InstallerAdapter;
+use Joomla\CMS\Language\Text;
+
+defined('_JEXEC') or die();
+
+trait TraitInstallerCheck
+{
+    /**
+     * @var bool
+     */
+    protected $cancelInstallation = false;
+
+    /**
+     * @param InstallerAdapter $parent
+     *
+     * @return bool
+     * @throws \Exception
+     */
+    protected function checkInheritance(InstallerAdapter $parent): bool
+    {
+        Factory::getLanguage()->load('lib_shackinstaller.sys', realpath(__DIR__ . '/../..'));
+
+        $parentClasses   = class_parents($this);
+        $scriptClassName = array_pop($parentClasses);
+        $scriptClass     = new \ReflectionClass($scriptClassName);
+
+        $sourcePath    = dirname($scriptClass->getFileName());
+        $sourceBase    = strpos($sourcePath, JPATH_PLUGINS) === 0 ? 3 : 2;
+        $sourceVersion = AbstractScript::VERSION ?? '0.0.0';
+
+        $sourcePath = $this->cleanPath($sourcePath);
+        $targetPath = $this->cleanPath(SHACK_INSTALLER_BASE);
+
+        if ($sourcePath != $targetPath && version_compare($sourceVersion, SHACK_INSTALLER_COMPATIBLE , 'lt')) {
+            $source = join('/', array_slice(explode('/', $sourcePath), 0, $sourceBase));
+
+            $errorMessage = 'LIB_SHACKINSTALLER_ABORT_'
+                . ($parent->getRoute() == 'uninstall' ? 'UNINSTALL' : 'INSTALL');
+
+            Factory::getApplication()->enqueueMessage(Text::sprintf($errorMessage, $source), 'error');
+
+            $this->cancelInstallation = true;
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $path
+     *
+     * @return string
+     */
+    protected function cleanPath(string $path): string
+    {
+        return str_replace(DIRECTORY_SEPARATOR, '/', str_replace(JPATH_ROOT . '/', '', $path));
+    }
+}

plugins/system/osmylicensesmanager/library/Installer/include.php

@@ -0,0 +1,53 @@
+<?php
+/**
+ * @package   ShackInstaller
+ * @contact   www.joomlashack.com, help@joomlashack.com
+ * @copyright 2016-2023 Joomlashack.com. All rights reserved
+ * @license   https://www.gnu.org/licenses/gpl.html GNU/GPL
+ *
+ * This file is part of ShackInstaller.
+ *
+ * ShackInstaller is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * ShackInstaller is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with ShackInstaller.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use Alledia\Installer\AutoLoader;
+use Joomla\CMS\Version;
+
+// phpcs:disable PSR1.Files.SideEffects
+defined('_JEXEC') or die();
+
+if (defined('SHACK_INSTALLER_BASE') == false) {
+    define('SHACK_INSTALLER_BASE', __DIR__);
+
+    require_once SHACK_INSTALLER_BASE . '/AutoLoader.php';
+}
+
+AutoLoader::register('Alledia\\Installer', __DIR__, true);
+
+if (defined('SHACK_INSTALLER_VERSION') == false) {
+    define('SHACK_INSTALLER_VERSION', '2.4.4');
+    define('SHACK_INSTALLER_COMPATIBLE', '2.4.0');
+
+    if (isset($reportErrors) == false) {
+        $reportErrors = E_ALL ^ E_DEPRECATED ^ E_USER_DEPRECATED;
+        if (Version::MAJOR_VERSION == 4) {
+            // There is a bad line of code in Joomla 4 that runs during extension install/update
+            $reportErrors = $reportErrors ^ E_NOTICE;
+        }
+    }
+
+    if ($reportErrors) {
+        set_error_handler('\\Alledia\\Installer\\AbstractScript::errorHandler', $reportErrors);
+    }
+}