Module.php

<?php

namespace Xanweb\Module;

use Concrete\Core\Application\Application;
use Concrete\Core\Entity\Package;
use Concrete\Core\Foundation\ClassAliasList;
use Concrete\Core\Foundation\Service\ProviderList;
use Concrete\Core\Package\Package as PackageController;
use Concrete\Core\Package\PackageService;
use Concrete\Core\Routing\RouteListInterface;
use Concrete\Core\Support\Facade\Application as FacadeApp;
use Concrete\Core\Support\Facade\Route;
use Illuminate\Support\Str;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Xanweb\Module\Asset\Provider;

/**
 * @method static string getPackagePath() @see \Concrete\Core\Package\Package::getPackagePath()
 * @method static string getRelativePath() @see \Concrete\Core\Package\Package::getRelativePath()
 */
abstract class Module implements ModuleInterface
{
 private static Application $app;

 /**
 * The resolved controller instances.
 *
 * @var array
 */
 private static array $resolvedPackController = [];

 /**
 * Class to be used Statically.
 */
 private function __construct()
 {
 }

 /**
 * Handle dynamic, static calls to the controller.
 *
 * @param string $method
 * @param array $args
 *
 * @return mixed
 */
 public static function __callStatic($method, $args)
 {
 return self::controller()->$method(...$args);
 }

 /**
 * {@inheritdoc}
 *
 * @see ModuleInterface::pkg()
 */
 public static function pkg(): Package
 {
 return self::controller()->getPackageEntity();
 }

 /**
 * {@inheritdoc}
 *
 * @see ModuleInterface::boot()
 */
 public static function boot(): void
 {
 // Register Class Aliases
 if (($aliases = static::getClassAliases()) !== []) {
 ClassAliasList::getInstance()->registerMultiple($aliases);
 }

 $app = self::app();
 // Register Service Providers
 if (($providers = static::getServiceProviders()) !== []) {
 $app->make(ProviderList::class)->registerProviders($providers);
 }

 // Register Route Lists
 if (($routeListClasses = static::getRoutesClasses()) !== []) {
 $router = Route::getFacadeRoot();
 foreach ($routeListClasses as $routeListClass) {
 if (is_subclass_of($routeListClass, RouteListInterface::class)) {
 $router->loadRouteList($app->make($routeListClass));
 } else {
 self::throwInvalidClassRuntimeException('getRoutesClasses', $routeListClass, RouteListInterface::class);
 }
 }
 }

 // Register Asset Providers
 $assetProviders = static::getAssetProviders();
 foreach ($assetProviders as $assetProviderClass) {
 if (is_subclass_of($assetProviderClass, Provider::class)) {
 $app->make($assetProviderClass, ['package' => static::pkg()])->register();
 } else {
 self::throwInvalidClassRuntimeException('getAssetProviders', $assetProviderClass, Provider::class);
 }
 }

 // Register Event Subscribers
 if (($evtSubscriberClasses = static::getEventSubscribers()) !== []) {
 $director = $app->make('director');
 foreach ($evtSubscriberClasses as $evtSubscriberClass) {
 if (is_subclass_of($evtSubscriberClass, EventSubscriberInterface::class)) {
 $director->addSubscriber($app->make($evtSubscriberClass));
 } else {
 self::throwInvalidClassRuntimeException('getEventSubscribers', $evtSubscriberClass, EventSubscriberInterface::class);
 }
 }
 }
 //register console commands
 if (($consoleCmdClasses = static::getConsoleCmds()) !== []) {
 foreach ($consoleCmdClasses as $cmdClass) {
 if ($app->has("console")) {
 $app->make("console")->add($app->make($cmdClass));
 }
 }
 }
 }

 public static function isInstalled(): bool
 {
 try {
 return static::pkg()->isPackageInstalled();
 } catch (\Throwable $e) {
 return false;
 }
 }

 /**
 * Get Database Config.
 *
 * @param string|null $key
 * @param mixed $default
 *
 * @return \Concrete\Core\Config\Repository\Liaison|mixed
 */
 final public static function getConfig(?string $key = null, $default = null)
 {
 $config = self::controller()->getDatabaseConfig();
 if ($key !== null) {
 return $config->get($key, $default);
 }

 return $config;
 }

 /**
 * Get File Config.
 *
 * @param string|null $key
 * @param mixed $default
 *
 * @return \Concrete\Core\Config\Repository\Liaison|mixed
 */
 final public static function getFileConfig(?string $key = null, $default = null)
 {
 $config = self::controller()->getFileConfig();
 if ($key !== null) {
 return $config->get($key, $default);
 }

 return $config;
 }

 /**
 * Classes to be registered as aliases in \Concrete\Core\Foundation\ClassAliasList.
 *
 * @return array
 */
 protected static function getClassAliases(): array
 {
 return [
 static::getPackageAlias() => static::class,
 ];
 }

 /**
 * Get Package Alias.
 *
 * @return string
 */
 protected static function getPackageAlias(): string
 {
 return Str::studly(static::pkgHandle());
 }

 /**
 * Get Service Providers Class Names.
 *
 * @return string[]
 */
 protected static function getServiceProviders(): array
 {
 return [];
 }

 /**
 * Get Classes names for RouteList, must be an instance of \Concrete\Core\Routing\RouteListInterface.
 *
 * @return string[]
 */
 protected static function getRoutesClasses(): array
 {
 return [];
 }

 /**
 * AssetProviders should be an instance of \Xanweb\Module\Asset\Provider.
 *
 * @return string[]
 */
 protected static function getAssetProviders(): array
 {
 return [];
 }

 /**
 * Event Subscribers should be an instance of \Symfony\Component\EventDispatcher\EventSubscriberInterface.
 *
 * @return string[]
 */
 protected static function getEventSubscribers(): array
 {
 return [];
 }

 /**
 * @param string $make [optional]
 *
 * @return Application|object
 */
 protected static function app($make = null)
 {
 if (!isset(self::$app)) {
 self::$app = FacadeApp::getFacadeApplication();
 }

 if ($make !== null) {
 return self::$app->make($make);
 }

 return self::$app;
 }

 private static function throwInvalidClassRuntimeException(string $relatedMethod, $targetClass, string $requiredClass): void
 {
 throw new \RuntimeException(t('%s:%s - `%s` should be an instance of `%s`', static::class, $relatedMethod, (string)$targetClass, $requiredClass));
 }

 private static function controller(): PackageController
 {
 $pkgHandle = static::pkgHandle();

 return self::$resolvedPackController[$pkgHandle] ??= self::app(PackageService::class)->getClass($pkgHandle);
 }

 /**
 * return list of CLI command class list
 * @return string[]
 */
 protected static function getConsoleCmds(): array
 {
 return [];
 }
}