lepton_abstract.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);


abstract class LEPTON_abstract
{
    const NOT_SET_IN_INFO = "(unknown - not set in info.php)";

    public array $language = [];

    public array $parents = [];

    public string $module_directory = "";

    public string $module_name = "";

    public string $module_function = "";

    public string $module_version = "";

    public string $module_platform = "";
    
    public int $module_delete = 1;

    public string $module_author = "";

    public string  $module_license = "";

    public string $module_license_terms = "";

    public string $module_description = "";

    public string $module_guid = "";

    public string $module_home = "";

    public static $instance;

    public static function getInstance(mixed $value = null): object
    {
        if (null === static::$instance)
        {
            static::$instance = new static();
            static::$instance->getParents();
            static::$instance->getLanguageFile();
            static::$instance->getModuleInfo();
            static::$instance->initialize($value);
        }
        return static::$instance;
    }

    protected function getParents(): void
    {
        // First the class itself
        static::$instance->parents[] = get_class(static::$instance);
 
        // Now the parents
        $aTempParents = class_parents(static::$instance, true);
        foreach($aTempParents as $sParentName)
        {
            static::$instance->parents[] = $sParentName;
        }
    }

    protected function getModuleInfo(): void
    {
 
        foreach(static::$instance->parents as $sModuleDirectoryTop)
        {
            //  strip namespace
            $aTemp = explode("\\", $sModuleDirectoryTop);
            foreach($aTemp as $sModuleDirectory)
            {             
 
                $aMainClassNames = $this->getMainClassNames( $sModuleDirectory );
 
                foreach($aMainClassNames as $sTempModuleDirectory)
                {
                    $sLookUpPath = __DIR__."/../../modules/".$sTempModuleDirectory."/info.php";
 
                    if( file_exists($sLookUpPath) )
                    {
                        require $sLookUpPath;
                        // [1.1] mandatory information
                        static::$instance->module_name = ($module_name ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_directory = ($module_directory ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_function = ($module_function ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_version = ($module_version ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_author = ($module_author ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_license = ($module_license ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_description = ($module_description ?? self::NOT_SET_IN_INFO);
                        static::$instance->module_guid = ($module_guid ?? self::NOT_SET_IN_INFO);
 
                        // [1.2] optional information
                        if(isset($module_platform))
                        {
                            static::$instance->module_platform = $module_platform;
                        }
                        if(isset($module_delete))
                        {
                            static::$instance->module_delete = intval($module_delete);
                        }                       
                        if(isset($module_license_terms))
                        {
                            static::$instance->module_license_terms = $module_license_terms;
                        }                       
                        if(isset($module_home))
                        {
                            static::$instance->module_home = $module_home;
                        }
                        break;
                    }
                }
            }            
        }
    }

    protected function getLanguageFile(): void
    {
        if(defined("LEPTON_PATH"))
        {
            $aLookUpFilenames = [
                LANGUAGE."_add.php",
                LANGUAGE."_custom.php",
                LANGUAGE.".php",
                "EN_add.php",
                "EN_custom.php",
                "EN.php"
            ];
 
            foreach (static::$instance->parents as $sClassNameTop)
            {
                //  strip namespace
                $aTemp = explode("\\", $sClassNameTop);
                $bExitGraceful = false;
                foreach( $aTemp as $sClassName )
                {          
                    $aMainClassNames = $this->getMainClassNames( $sClassName );
 
                    foreach($aMainClassNames as $sTempModuleDirectory)
                    {
                        $lookUpPath = LEPTON_PATH."/modules/".$sTempModuleDirectory."/languages/";
 
                        $bFoundFile = false;
 
                        $sUsedFilename = "";
                        foreach ($aLookUpFilenames as $sTempFilename)
                        {
                            if (true === file_exists($lookUpPath.$sTempFilename))
                            {
                                require $lookUpPath.$sTempFilename;
                                $sUsedFilename = $sTempFilename;
                                $bFoundFile = true;
                                break;
                            }
                        }
 
                        if (false === $bFoundFile)
                        {
                            continue;
                        }
 
                        $tempName = "MOD_".strtoupper($sTempModuleDirectory);
                        if (isset(${$tempName}))
                        {
                            if (str_contains($sUsedFilename, "_add.php"))
                            {
                                $sDefaultFileName = str_replace("_add", "", $sUsedFilename);
                                $aLanguageAdd = ${$tempName};
 
                                require $lookUpPath.$sDefaultFileName;
 
                                ${$tempName} = array_merge(${$tempName}, $aLanguageAdd);
                            }
 
                            static::$instance->language = ${$tempName};
                            $bExitGraceful = true;
                            break;
                        }
                    }
                    
                    if (true === $bExitGraceful)
                    {
                        break;
                    }
                }
            }
        }
    }

    public function getHeadInfo(): array
    {
        return array(
            "title"         => "",
            "description"   => "",
            "keywords"      => ""
        );
    }

    protected function getMainClassNames( $sAnyClassname )
    {
        $aElements = explode("_",  $sAnyClassname);
 
        $sTempName = array_shift($aElements);
 
        $aReturnValue = array( $sTempName );
 
        foreach($aElements as $term)
        {
            $sTempName .= "_".$term;
            $aReturnValue[] = $sTempName;
        }
 
        if( 1 < count($aReturnValue) )
        {
            $aReturnValue = array_reverse( $aReturnValue );
        }
 
        return $aReturnValue;
    }

    public static function saveLastEditSection(int $iSectionID = 0): void
    {
        if ($iSectionID === 0)
        {
            if (true === isset($GLOBALS['section_id']))
            {
                $_SESSION['last_edit_section'] = $GLOBALS['section_id'];
            }
        } else {
            $_SESSION['last_edit_section'] = $iSectionID;
        }
    }
 
    public static function getConstants(): array
    {
        // "static::class" here does the magic
        $reflectionClass = new \ReflectionClass(static::class);
        return $reflectionClass->getConstants();
    }

    abstract protected function initialize();
 
        
    public function getEditorSettings()
    {
        // [1] base class name
        $sBaseClassName = $this->parents[0];
        
        // [2] custom class?
        $sCustom = (class_exists( $sBaseClassName."_settings_custom", true)) ? "_custom" : "";
        // [2.1] class exists?
        if(class_exists($sBaseClassName."_settings".$sCustom, true))
        {
            //  [2.2] try to get instance of the class
            return eval("return ".$sBaseClassName."_settings".$sCustom."::getInstance();");    
        }
        else
        {   
            //  [2.3] class not exists - return NULL
            return NULL;
        }
    }
    
    public function getAdditionalClass( string $basename="settings", string $classname="") : mixed
    {
        // [1] Basename
        if($classname === "")
        {
            $classname = $this->parents[0];
        }
        
        // [2] Custom?
        $custom = (class_exists($classname."_".$basename."_custom", true)) ? "_custom" : "";
        
        // [3] class exists?
        if( class_exists( $classname."_".$basename.$custom, true))
        {
            return eval("return ".$classname."_".$basename.$custom."::getInstance();");
        }
        else
        {
            return NULL;
        }
    }
}