developer.jelix.org is not used any more and exists only for history. Post new tickets on the Github account.
developer.jelix.org n'est plus utilisée, et existe uniquement pour son historique. Postez les nouveaux tickets sur le compte github.

Ticket #31: Installer.patch

File Installer.patch, 18.8 KB (added by foxmask, 12 years ago)

Patch of classes jInstaller+jInstallerModule+jInstallerApp

  • jInstaller.class.php

     
    1515     * @return jInstallerApp
    1616     */
    1717    static function getApplication() {
     18        #let's give the path to the JELIX_APP_PATH where is located the project.xml       
     19        return new jInstallerApp(JELIX_APP_PATH);
    1820       
    19        
    2021    }
    2122
    2223    /**
     
    5051     */
    5152    static function install($list) {
    5253        // call the install() method of each object.
     54       
     55        if ($list instanceof jInstallerModule) {
     56               return  $list->install();
     57        }
    5358    }
    5459
    5560    /**
     
    5964     */
    6065    static function uninstall($list) {
    6166        // call the uninstall() method of each object.
     67       
     68        if ($list instanceof jInstallerModule) {
     69               return  $list->uninstall();
     70        }       
    6271    }
    6372
    6473    const STATUS_INSTALLED = 1;
     
    7382     * @return array array of jInstallerModule
    7483     */
    7584    static function getModulesList($status = 0) {
     85       
     86        global $gJConfig;
     87        $modules = array();
     88                       
     89        //@TODO : get the module for a given combination of status
     90        switch ($status ) {
    7691
     92            case self::STATUS_INSTALLED :
     93                $modules = self::getInstalledModules();
     94                break;
     95           
     96            case self::STATUS_UNINSTALLED :
     97                $modules = self::getUninstalledModules();
     98                break;
     99               
     100            case self::STATUS_ACTIVATED :
     101                $modules = self::getActivatedModules();
     102                break;
     103
     104            case self::STATUS_DEACTIVATED :
     105                $modules = self::getDeactivatedModules();
     106                break;
     107           
     108            case self::STATUS_ALL :
     109                $modules = self::getAllModules();
     110                break;
     111        }
     112       
     113        return $modules;
     114           
    77115    }
    78116
    79117    /**
     
    81119     * @return jInstallerModule
    82120     */
    83121    static function getModuleById($id) {
    84    
     122        #get Modules whatever the status => 0
     123        $modules = self::loadModules();
     124
     125        foreach ($modules as $key=>$module) {
     126            if (in_array($id,$module)) {
     127                return $module;
     128            }
     129        }
     130
     131       
    85132    }
    86133
    87134    /**
    88135     * get a module by its name
    89136     * @return jInstallerModule
    90137     */
    91     static function getModule($name) {
     138    static function getModule($name) {     
     139        $module = array();
     140        global $gJConfig;
     141       
     142        $modulesList = $gJConfig->_modulesPathList;       
     143        $application = self::getApplication();
     144
     145        if (array_key_exists($name,$modulesList) and file_exists($modulesList[$name].'/module.xml')) {
     146            $jIm = new jInstallerModule($name,$application);
     147            $module = $jIm->readModuleXml();
     148        }
     149        return $module;
     150    }
     151
     152    const MODULE_INI_FILE = 'module.ini.php';
     153    /*
     154     * load the Module config file that's storing the statment of each module
     155     *
     156     */
     157        static function loadModuleIniConfig() {       
     158                $config =  new jIniFileModifier(JELIX_APP_CONFIG_PATH.self::MODULE_INI_FILE);
     159        return $config;
     160    }
     161
     162    /*
     163     *
     164     * load all the module.xml file in array
     165     *
     166     */
     167    private static function loadModules() {
     168        global $gJConfig;
     169       
     170        $modulesList = $gJConfig->_modulesPathList;
     171       
     172        $modules = array();       
     173        $application = self::getApplication();
     174       
     175        foreach($modulesList as $k=>$path){
     176           
     177            #we want all the modules in modulesPath except the core and jelix one.
     178            if (  preg_match('#/([A-Za-z0-9_-]+)/$#',$path,$m) and
     179                ! preg_match('#[core|jelix]-modules#',$path)) {
     180
     181                if (file_exists($path.'/module.xml')) {
     182                    $jIm = new jInstallerModule($m[1],$application);
     183                    $modules[$m[1]] = $jIm->readModuleXml();
     184                }               
     185               
     186            }
     187        }
     188       
     189        return $modules;
     190       
     191    }
     192
     193    /*
     194     *
     195     * get the status of each module
     196     *
     197     * @param string $status status can be 'installed' 'activated'
     198     * @param boolean $flag flag
     199     * @return array of modules we searched
     200     */
     201    private static function getStatusModule($status,$flag) {           
     202        $modules = array();
     203        #1) load the config module file to get the ID of each existing modules
     204        $config = self::loadModuleIniConfig();       
     205        $application = self::getApplication();
     206       
     207        #2) load the module.xml file of each module
     208        $moduleLoaded = self::loadModules();
     209       
     210        #3) if we want to get all the module ...
     211        if ($status == 'all' ) {   
     212            return $moduleLoaded;
     213       
     214        #3.bis) if we want to get all module with a specific status :
     215        } else {
     216            #now $moduleLoaded contains the module ID
     217            #we use to identify a section in the module config file
     218            foreach($moduleLoaded as $name => $module){
     219                if ( $config->getValue($status,$module['id']) === $flag ) {
     220                    $jIm = new jInstallerModule($name,$application);
     221                    $modules[$name] = $jIm->readModuleXml();
     222                }
     223               
     224            }
     225           
     226            return $modules;
     227        }
     228       
     229       
     230       
     231       
     232    }
     233       
     234    /**
     235     * get all the Activated modules
     236     *
     237     * @return array  The array of all the activated modules found in the config file
     238     */           
     239    private static function getActivatedModules() {
     240
     241        return self::getStatusModule('activated',1);
     242    }
     243       
     244
     245    /**
     246     * get all the Deactivated modules
     247     *
     248     * @return array  The array of all the deactivated modules found in the config file
     249     */                 
     250    private static function getDeactivatedModules() {
     251       
     252        return self::getStatusModule('activated',0);
     253    }
     254       
     255    /**
     256     * get all the Installed modules
     257     *
     258     * @return array  The array of all the installed modules found in the config file
     259     */   
     260    private static function getInstalledModules() {
     261       
     262        return self::getStatusModule('installed',1);
     263       
     264    }
    92265   
     266    /**
     267     * get all the UnInstalled modules
     268     *
     269     * @return array  The array of all the modules NOT found in the config file
     270     */     
     271    private static function getUninstalledModules() {
     272       
     273        return self::getStatusModule('installed',0);
     274       
    93275    }
    94276
    95277    /**
     278     * get all the UnInstalled modules
     279     *
     280     * @return array  The array of all the modules NOT found in the config file
     281     */     
     282    private static function getAllModules() {
     283       
     284        return self::getStatusModule('all',0);
     285       
     286    }   
     287   
     288   
     289    /*******************************
     290     *** PLUGINS
     291     ********************************/
     292
     293    /**
    96294     * return the list of plugins
    97295     * @param integer $status  combination of STATUS_*
    98296     * @return array array of jInstallerPlugin
     
    114312     */
    115313    static function getPlugin($name) {
    116314   
    117     }
    118 
     315    }   
     316   
    119317}
     318 No newline at end of file
  • jInstallerApp.class.php

     
    5959        // if the config file is not used by another entrypoint, remove it
    6060    }
    6161
     62    function isActivated() {
     63       
     64    }
     65   
     66    function isInstalled() {
     67       
     68    }
     69   
     70    function install() {
     71       
     72    }
     73   
     74    function uninstall() {
     75       
     76    }
     77   
     78    function activate() {
     79       
     80    }
     81   
     82    function deactivate() {
     83       
     84    }
    6285}
    6386
  • jInstallerModule.class.php

     
    2020class jInstallerModule extends jInstallerBase {
    2121
    2222    protected $application;
     23       
     24        #Vars used for XPath Query.
     25        #fake ns needed to register the URL of our own jelix module schema
     26        private $ns ;
     27    private $nsURL ;
     28       
     29        #the complet path to the config file
     30        private $configIni;
     31   
     32        #Vars for module management
     33    #the content of $gJConfig->_modulesPathList
     34    private $moduleList;
     35   
     36    #the full path to the module.xml file of the current module
     37    private $moduleXmlPath;
    2338
     39    #the full path of the current module
     40    private $modulePath;
     41   
     42    #the current module ID
     43    private $moduleId;
     44       
     45       
     46   
    2447    /**
    2548     * The module should be present in the application.
    2649     * @param string $name the name of the module
    2750     * @param jInstallerApp $application
    28      */
     51     */   
    2952    function __construct($name, $application) {
    3053        // read the module.xml
    3154        // and set the $path property
     55       
     56        global $gJConfig;
     57        $this->moduleList = $gJConfig->_modulesPathList;
     58       
     59        #check if this module is in the "classpath" of all the modules
     60        #delcared in the defaultconfig.ini.php file
     61        if (in_array($name,$this->moduleList))
     62            throw new jException('jelix~moduleinstaller.invalid.module');
     63       
     64        #let set some properties
     65        else {
     66            $this->ns           =  'jelixmodule';
     67            $this->nsURL        = 'http://jelix.org/ns/module/1.0';
     68            $this->configIni    = JELIX_APP_CONFIG_PATH.'module.ini.php';
     69            $this->moduleXmlPath = $this->moduleList[$name].'/module.xml';
     70            $this->modulePath   = $this->moduleList[$name];
     71            $this->moduleId     = $this->moduleInfo('info/@id');
     72        }
     73       
    3274    }
    3375
    3476    /**
    3577     * @return boolean true if the module is installed
    3678     */
    3779    function isInstalled() {
    38        
     80                $config = jInstaller::loadModuleIniConfig();
     81                #$return can be 1/0/NULL (if not in the module.ini.php file)
     82        $return = (boolean) $config->getValue('installed',$this->moduleId);
     83        return ($return === NULL) ? false  : $return;
    3984    }
    40 
    4185    /**
     86     * @return boolean true if the module is activated
     87     */
     88    function isActivated() {
     89        $config = jInstaller::loadModuleIniConfig();
     90                #$return can be 1/0/NULL (if not in the module.ini.php file)
     91        $return = (boolean) $config->getValue('activated',$this->moduleId);
     92        return ($return === NULL) ? 0  : $return;
     93    }
     94   
     95    /**
    4296     * install the module, by checking dependencies.
    4397     * @throw jException  if an error occurs during the install.
    4498     */
    4599    function install() {
    46 
     100                // @ROADMAP
    47101        // * check that all dependencies are ok : the needed modules and plugins
    48102        // should be present in the application, even if this modules or plugins
    49103        // are not install
     
    56110        // * if error, uninstall dependencies which have just been installed,
    57111        //   undo things which have made during the install of the module, and
    58112        //   throw an exception
     113               
     114                //@TODO : check dependencies + installation of them
     115                // currently this method install the module alone
     116        if ($this->isInstalled() === false) {
     117
     118                        $installed = $this->runModuleFile($this->modulePath.'/install/_install.php');
     119                       
     120                        if ($installed === true) {             
     121                               
     122                                return true;
     123            }
     124            else
     125                throw new jException('jelix~moduleinstaller.version.are.the.same');
     126        }
     127        else
     128            throw new jException('jelix~moduleinstaller.module.still.installed');
     129       
     130                return null;
     131       
    59132    }
    60133   
    61134    /**
     
    67140        // should be present in the application
    68141        // * start the uninstall of all needed modules and plugins before installing
    69142        // the module.
    70         // * if ok, uninstall the module, by calling the _uninstall.php script     
     143        // * if ok, uninstall the module, by calling the _uninstall.php script
     144       
     145                //@TODO : same as install method above
     146        if ($this->isInstalled() === true) {
     147           
     148            $uninstalled = $this->runModuleFile($this->modulePath.'/install/_uninstall.php');
     149           
     150                        if ($uninstalled === true) {
     151                               
     152                                return true;
     153                        }           
     154                       
     155                }
     156        else
     157            throw new jException('jelix~moduleinstaller.cant.uninstall.module.that.is.not.installed');
     158       
     159       
     160                return null;       
    71161    }
    72162   
     163    /**
     164     * delete the current module
     165     * @return mixed null if not
     166     */ 
     167        public function delete() {
     168                try {
     169                        //@TODO : check if the module exist
     170            jFile::removeDir($this->modulePath,true);
     171                        return true;
     172                       
     173                } catch (Exception $e) {
     174                        return $e->getMessage();
     175                }
     176               
     177                return null;
     178        }   
     179   
     180    /**
     181     * get the modules
     182     * @param string $filename complet path to the file containing installation process
     183     * @return mixed nothing or the required filename
     184     */   
     185        private function runModuleFile($filename) {
     186                if (!file_exists($filename)) {
     187                        return;
     188                }
     189               
     190                return require $filename;
     191        }
     192
     193
     194    /**
     195     * get info for a given module by doing a XPAth Query !
     196     * @param string $info the XPath query to do eg 'version/text()' to retreive the version number
     197     * @return string $value the value result of the XPath query
     198     */
     199        function moduleInfo($info) {
     200
     201                $doc = new DOMDocument;
     202                $doc->Load($this->moduleXmlPath);
     203               
     204                $xpath  = new DOMXPath($doc);
     205                $xpath->registerNamespace($this->ns,$this->nsURL);
     206           
     207                $query = '//'.$this->ns.':'.$info;
     208                $entries = $xpath->query($query);
     209               
     210        //@TODO do a loop on entries if item > 0
     211                $value = $entries->item(0)->nodeValue;
     212               
     213                return $value;
     214        }
     215   
     216    /**
     217     * set the status of a given module
     218     *
     219     * @param string $status The status of a module we set into the config file
     220     * @param string $flag   flag to (de)activate/(un)install a module
     221     */         
     222        private function setStatusModule($status,$flag) {               
     223               
     224                $config = jInstaller::loadModuleIniConfig();
     225                $config->setValue($status,$flag,$this->moduleId);
     226                $config->save();
     227               
     228        }
     229       
     230       
     231    /**
     232     * activate the given module
     233     */ 
    73234    function activate() {
     235               
     236                $this->setStatusModule('activated',1);
     237               
    74238    }
    75239   
     240    /**
     241     * deactivate the given module
     242     */     
    76243    function deactivate() {
     244
     245                $this->setStatusModule('activated',0);
     246
     247    }
     248   
     249
     250    /**
     251     * get the version of the module
     252     * @param string $id the module ID of the module
     253     */         
     254        public function getVersionModule() {           
     255               
     256                $config = jInstaller::loadModuleIniConfig();
     257                return $config->getValue('version',$this->moduleId);
     258        }
     259               
     260    /**
     261     * set the version of the module
     262     * @param array $status the status to set to the module
     263     * @param string $version the version to set to the module
     264     */
     265        public function setVersionModule($status=array(),$version=0) {
     266
     267                $config = jInstaller::loadModuleIniConfig();
     268                $config->setValue('version',$version,$this->moduleId);
     269        if (!empty($status))
     270            foreach ($status as $stat=>$k)
     271                $config->setValue($stat,$k,$this->moduleId);
     272        else {
     273            $config->setValue('installed',1,$this->moduleId);
     274            $config->setValue('activated',1,$this->moduleId);
     275        }
     276                $config->save();                       
     277               
     278        }
     279       
     280    /**
     281     * delete the version of the module
     282     */         
     283        public function delVersionModule() {
     284                //@TODO : check if the module is installed
     285                $config = jInstaller::loadModuleIniConfig();
     286                $config->setValue('installed',0,$this->moduleId);
     287        $config->setValue('version',0,$this->moduleId);
     288                $config->setValue('activated',0,$this->moduleId);
     289                $config->save();       
     290        }
     291   
     292    /**
     293     * parse the module.xml file
     294     * @param array $list all the module.xml file
     295     * @return array $module_info all the infos of a module in an array
     296     */
     297    public function readModuleXml(){
     298        $moduleInfos = array();
     299               
     300                $doc = new DOMDocument;
     301                $doc->Load($this->moduleXmlPath);
    77302       
    78     }
     303        $xpath  = new DOMXPath($doc);
     304        $xpath->registerNamespace($this->ns,$this->nsURL);
     305
     306        $query = '//'.$this->ns.':info/@id';
     307        $entries = $xpath->query($query);
     308       
     309        $moduleId =  $entries->item(0)->nodeValue;
     310       
     311        $query = '//'.$this->ns.':info/@name';
     312        $entries = $xpath->query($query);
     313       
     314        $moduleName =  $entries->item(0)->nodeValue;
     315       
     316        $query = '//'.$this->ns.':version/@stability';
     317        $entries = $xpath->query($query);
     318
     319        $versionStability = $entries->item(0)->nodeValue;
     320
     321        $query = '//'.$this->ns.':version/text()';
     322        $entries = $xpath->query($query);
     323       
     324        $versionNumber = $entries->item(0)->nodeValue;
     325
     326        $query = '//'.$this->ns.':label/text()';
     327        $entries = $xpath->query($query);
     328       
     329        $label = $entries->item(0)->nodeValue;
     330
     331        $creators = array();
     332        $query = '//'.$this->ns.':creator';
     333       
     334        $entries = $xpath->query($query);
     335
     336        foreach ($entries as $entry) {
     337            $creatorName = '';
     338            $creatorNickname = '';
     339            $creatorEmail = '';
     340            $creatorActive = '';
     341            if ($entry->hasAttribute('name'))
     342                $creatorName = $entry->getAttribute('name');
     343            else {
     344                die("fichier module.xml invalide");
     345            }
     346            if ($entry->hasAttribute('nickname'))
     347                $creatorNickname = $entry->getAttribute('nickname');
     348            if ($entry->hasAttribute('email'))
     349                $creatorEmail = $entry->getAttribute('email');
     350            if ($entry->hasAttribute('active'))
     351                $creatorActive = $entry->getAttribute('active');
     352               
     353            $creators[] = array('name'=>$creatorName,
     354                                'nickname'=>$creatorNickname,
     355                                'email'=>$creatorEmail,
     356                                'active'=>$creatorActive);
     357        }
     358       
     359       
     360                   
     361        $query = '//'.$this->ns.':notes';
     362        $entries = $xpath->query($query);
     363       
     364        $notes = $entries->item(0)->nodeValue;
     365           
     366        //@TODO : extend the properties of the array to all the
     367                // existing nodes of the module.xml schema, eg: dependencies
     368        $moduleInfos = array(
     369                        'id'=>$moduleId,
     370                        'version'=>$versionStability . ' ' . $versionNumber,
     371                        'desc'=>$label,
     372                        'creators'=>$creators,
     373                        'notes'=>$notes);
     374   
     375   
     376        return $moduleInfos;
     377       
     378    }   
    79379}
    80380