protected function expandPath($path)
{
if (strpos($path, 'www:') === 0) {
$path = str_replace('www:', App::wwwPath(), $path);
} elseif (strpos($path, 'jelixwww:') === 0) {
$p = $this->config->getValue('jelixWWWPath', 'urlengine');
if (substr($p, -1) != '/') {
$p .= '/';
}
$path = str_replace('jelixwww:', App::wwwPath($p), $path);
} elseif (strpos($path, 'config:') === 0) {
$path = str_replace('config:', App::configPath(), $path);
} elseif (strpos($path, 'appconfig:') === 0) {
$path = str_replace('appconfig:', App::appConfigPath(), $path);
} elseif (strpos($path, 'epconfig:') === 0) {
$p = dirname(App::appConfigPath($this->entryPoint->getConfigFile()));
$path = str_replace('epconfig:', $p . '/', $path);
}
return $path;
}
/**
* calculate miscelaneous path, depending of the server configuration and other informations
* in the given array : script path, script name, documentRoot ..
* @param array $urlconf urlengine configuration. scriptNameServerVariable, basePath,
* jelixWWWPath and jqueryPath should be present
*/
protected function getPaths(&$urlconf, $pseudoScriptName = '', $isCli = false)
{
// retrieve the script path+name.
// for cli, it will be the path from the directory were we execute the script (given to the php exec).
// for web, it is the path from the root of the url
if ($pseudoScriptName) {
$urlconf['urlScript'] = $pseudoScriptName;
} else {
if ($urlconf['scriptNameServerVariable'] == '') {
$urlconf['scriptNameServerVariable'] = self::findServerName('.php', $isCli);
}
$urlconf['urlScript'] = $_SERVER[$urlconf['scriptNameServerVariable']];
}
// now we separate the path and the name of the script, and then the basePath
if ($isCli) {
$lastslash = strrpos($urlconf['urlScript'], DIRECTORY_SEPARATOR);
if ($lastslash === false) {
$urlconf['urlScriptPath'] = $pseudoScriptName ? App::appPath('/scripts/') : getcwd() . '/';
$urlconf['urlScriptName'] = $urlconf['urlScript'];
} else {
$urlconf['urlScriptPath'] = getcwd() . '/' . substr($urlconf['urlScript'], 0, $lastslash) . '/';
$urlconf['urlScriptName'] = substr($urlconf['urlScript'], $lastslash + 1);
}
$basepath = $urlconf['urlScriptPath'];
$snp = $urlconf['urlScriptName'];
$urlconf['urlScript'] = $basepath . $snp;
} else {
$lastslash = strrpos($urlconf['urlScript'], '/');
$urlconf['urlScriptPath'] = substr($urlconf['urlScript'], 0, $lastslash) . '/';
$urlconf['urlScriptName'] = substr($urlconf['urlScript'], $lastslash + 1);
$basepath = $urlconf['basePath'];
if ($basepath == '') {
// for beginners or simple site, we "guess" the base path
$basepath = $localBasePath = $urlconf['urlScriptPath'];
} else {
if ($basepath != '/') {
if ($basepath[0] != '/') {
$basepath = '/' . $basepath;
}
if (substr($basepath, -1) != '/') {
$basepath .= '/';
}
}
if ($pseudoScriptName) {
// with pseudoScriptName, we aren't in a true context, we could be in a cli context
// (the installer), and we want the path like when we are in a web context.
// $pseudoScriptName is supposed to be relative to the basePath
$urlconf['urlScriptPath'] = substr($basepath, 0, -1) . $urlconf['urlScriptPath'];
$urlconf['urlScript'] = $urlconf['urlScriptPath'] . $urlconf['urlScriptName'];
}
$localBasePath = $basepath;
if ($urlconf['backendBasePath']) {
$localBasePath = $urlconf['backendBasePath'];
// we have to change urlScriptPath. it may contains the base path of the backend server
// we should replace this base path by the basePath of the frontend server
if (strpos($urlconf['urlScriptPath'], $urlconf['backendBasePath']) === 0) {
$urlconf['urlScriptPath'] = $basepath . substr($urlconf['urlScriptPath'], strlen($urlconf['backendBasePath']));
} else {
$urlconf['urlScriptPath'] = $basepath . substr($urlconf['urlScriptPath'], 1);
}
} elseif (strpos($urlconf['urlScriptPath'], $basepath) !== 0) {
throw new Exception('Error in main configuration on basePath -- basePath (' . $basepath . ') in config file doesn\'t correspond to current base path. You should setup it to ' . $urlconf['urlScriptPath']);
}
}
$urlconf['basePath'] = $basepath;
if ($urlconf['jelixWWWPath'][0] != '/') {
$urlconf['jelixWWWPath'] = $basepath . $urlconf['jelixWWWPath'];
}
if ($urlconf['jqueryPath'][0] != '/') {
$urlconf['jqueryPath'] = $basepath . $urlconf['jqueryPath'];
}
$snp = substr($urlconf['urlScript'], strlen($localBasePath));
if ($localBasePath == '/') {
$urlconf['documentRoot'] = App::wwwPath();
} else {
if (strpos(App::wwwPath(), $localBasePath) === false) {
if (isset($_SERVER['DOCUMENT_ROOT'])) {
$urlconf['documentRoot'] = $_SERVER['DOCUMENT_ROOT'];
} else {
$urlconf['documentRoot'] = App::wwwPath();
}
} else {
$urlconf['documentRoot'] = substr(App::wwwPath(), 0, -strlen($localBasePath));
}
}
}
$pos = strrpos($snp, '.php');
if ($pos !== false) {
$snp = substr($snp, 0, $pos);
}
$urlconf['urlScriptId'] = $snp;
$urlconf['urlScriptIdenc'] = rawurlencode($snp);
}
function checkAppPaths()
{
$ok = true;
if (!defined('JELIX_LIB_PATH') || !App::isInit()) {
throw new \Exception($this->messages->get('path.core'));
}
if (!file_exists(App::tempBasePath()) || !is_writable(App::tempBasePath())) {
$this->error('path.temp');
$ok = false;
}
if (!file_exists(App::logPath()) || !is_writable(App::logPath())) {
$this->error('path.log');
$ok = false;
}
if (!file_exists(App::varPath())) {
$this->error('path.var');
$ok = false;
}
if (!file_exists(App::appConfigPath())) {
$this->error('path.config');
$ok = false;
}
if (!file_exists(App::configPath())) {
$this->error('path.config');
$ok = false;
} elseif ($this->checkForInstallation) {
if (!is_writable(App::configPath())) {
$this->error('path.config.writable');
$ok = false;
}
if (file_exists(App::configPath('profiles.ini.php')) && !is_writable(App::configPath('profiles.ini.php'))) {
$this->error('path.profiles.writable');
$ok = false;
}
if (file_exists(App::configPath('installer.ini.php')) && !is_writable(App::configPath('installer.ini.php'))) {
$this->error('path.installer.writable');
$ok = false;
}
}
if (!file_exists(App::wwwPath())) {
$this->error('path.www');
$ok = false;
}
foreach ($this->otherPaths as $path) {
$realPath = \jFile::parseJelixPath($path);
if (!file_exists($realPath)) {
$this->error('path.custom.not.exists', array($path));
$ok = false;
} else {
if (!is_writable($realPath)) {
$this->error('path.custom.writable', array($path));
$ok = false;
} else {
$this->ok('path.custom.ok', array($path));
}
}
}
if ($ok) {
$this->ok('paths.ok');
} else {
throw new \Exception($this->messages->get('too.critical.error'));
}
return $ok;
}
public static function wwwPath($file = '')
{
return \Jelix\Core\App::wwwPath($file);
}
public function run()
{
// retrieve the type of entry point we want to create
$type = $this->getOption('-type');
if (!$type) {
$type = 'classic';
} else {
if (!in_array($type, array('classic', 'jsonrpc', 'xmlrpc', 'soap', 'cmdline'))) {
throw new Exception("invalid type");
}
}
// retrieve the name of the entry point
$name = $this->getParam('name');
if (preg_match('/(.*)\\.php$/', $name, $m)) {
$name = $m[1];
}
// the full path of the entry point
if ($type == 'cmdline') {
$entryPointFullPath = App::scriptsPath($name . '.php');
$entryPointTemplate = 'scripts/cmdline.php.tpl';
} else {
$entryPointFullPath = App::wwwPath($name . '.php');
$entryPointTemplate = 'www/' . ($type == 'classic' ? 'index' : $type) . '.php.tpl';
}
if (file_exists($entryPointFullPath)) {
throw new Exception("the entry point already exists");
}
$entryPointDir = dirname($entryPointFullPath) . '/';
$this->loadAppInfos();
// retrieve the config file name
$configFile = $this->getParam('config');
if ($configFile == null) {
if ($type == 'cmdline') {
$configFile = 'cmdline/' . $name . '.ini.php';
} else {
$configFile = $name . '/config.ini.php';
}
}
// let's create the config file if needed
$configFilePath = App::configPath($configFile);
if (!file_exists($configFilePath)) {
$this->createDir(dirname($configFilePath));
// the file doesn't exists
// if there is a -copy-config parameter, we copy this file
$originalConfig = $this->getOption('-copy-config');
if ($originalConfig) {
if (!file_exists(App::configPath($originalConfig))) {
throw new Exception("unknown original configuration file");
}
file_put_contents($configFilePath, file_get_contents(App::configPath($originalConfig)));
if ($this->verbose()) {
echo "Configuration file {$configFile} has been created from the config file {$originalConfig}.\n";
}
} else {
// else we create a new config file, with the startmodule of the default
// config as a module name.
$mainConfig = parse_ini_file(App::mainConfigFile(), true);
$param = array();
if (isset($mainConfig['startModule'])) {
$param['modulename'] = $mainConfig['startModule'];
} else {
$param['modulename'] = 'jelix';
}
$this->createFile($configFilePath, 'var/config/index/config.ini.php.tpl', $param, "Configuration file");
}
}
$inifile = new \Jelix\IniFile\MultiIniModifier(App::mainConfigFile(), $configFilePath);
$param = array();
$param['modulename'] = $inifile->getValue('startModule');
// creation of the entry point
$this->createDir($entryPointDir);
$param['rp_app'] = $this->getRelativePath($entryPointDir, App::appPath());
$param['config_file'] = $configFile;
$this->createFile($entryPointFullPath, $entryPointTemplate, $param, "Entry point");
if ($type != 'cmdline') {
if (null === $inifile->getValue($name, 'simple_urlengine_entrypoints', null, true)) {
$inifile->setValue($name, '', 'simple_urlengine_entrypoints', null, true);
}
if (null === $inifile->getValue($name, 'basic_significant_urlengine_entrypoints', null, true)) {
$inifile->setValue($name, '1', 'basic_significant_urlengine_entrypoints', null, true);
}
$inifile->save();
}
$this->appInfos->addEntryPointInfo($name . ".php", $configFile, $type);
if ($this->verbose()) {
echo $this->appInfos->getFile() . " has been updated.\n";
}
$installer = new \Jelix\Installer\Installer(new \Jelix\Installer\Reporter\Console('warning'));
$installer->installEntryPoint($name . ".php");
if ($this->verbose()) {
echo "All modules have been initialized for the new entry point.\n";
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
// retrieve the type of entry point we want to create
$type = $input->getOption('type');
if (!in_array($type, array('classic', 'jsonrpc', 'xmlrpc', 'soap', 'cmdline'))) {
throw new \Exception("invalid type");
}
// retrieve the name of the entry point
$name = $input->getArgument('entrypoint');
if (preg_match('/(.*)\\.php$/', $name, $m)) {
$name = $m[1];
}
// the full path of the entry point
if ($type == 'cmdline') {
$entryPointFullPath = App::scriptsPath($name . '.php');
$entryPointTemplate = 'scripts/cmdline.php.tpl';
} else {
$entryPointFullPath = App::wwwPath($name . '.php');
$entryPointTemplate = 'www/' . ($type == 'classic' ? 'index' : $type) . '.php.tpl';
}
if (file_exists($entryPointFullPath)) {
throw new \Exception("the entry point already exists");
}
$entryPointDir = dirname($entryPointFullPath) . '/';
$this->loadAppInfos();
// retrieve the config file name
$configFile = $input->getArgument('config');
if ($configFile == null) {
if ($type == 'cmdline') {
$configFile = 'cmdline/' . $name . '.ini.php';
} else {
$configFile = $name . '/config.ini.php';
}
}
// let's create the config file if needed
$configFilePath = App::appConfigPath($configFile);
if (!file_exists($configFilePath)) {
$this->createDir(dirname($configFilePath));
// the file doesn't exists
// if there is a -copy-config parameter, we copy this file
$originalConfig = $input->getOption('copy-config');
if ($originalConfig) {
if (!file_exists(App::appConfigPath($originalConfig))) {
throw new \Exception("unknown original configuration file");
}
file_put_contents($configFilePath, file_get_contents(App::appConfigPath($originalConfig)));
if ($this->verbose()) {
$output->writeln("Configuration file {$configFile} has been created from the config file {$originalConfig}.");
}
} else {
// else we create a new config file
$param = array();
$this->createFile($configFilePath, 'app/config/index/config.ini.php.tpl', $param, "Configuration file");
}
}
$inifile = new \Jelix\IniFile\MultiIniModifier(App::mainConfigFile(), $configFilePath);
$urlsFile = App::appConfigPath($inifile->getValue('significantFile', 'urlengine'));
$xmlMap = new \Jelix\Routing\UrlMapping\XmlMapModifier($urlsFile, true);
$param = array();
// creation of the entry point
$this->createDir($entryPointDir);
$param['rp_app'] = Path::shortestPath($entryPointDir, App::appPath());
$param['config_file'] = $configFile;
$this->createFile($entryPointFullPath, $entryPointTemplate, $param, "Entry point");
if ($type != 'cmdline') {
$xmlEp = $xmlMap->addEntryPoint($name, $type);
/*if ($type == 'classic') {
$xmlEp->addUrlAction('/', $module, $action);
}*/
$xmlMap->save();
}
$this->appInfos->addEntryPointInfo($name . ".php", $configFile, $type);
if ($this->verbose()) {
$output->writeln($this->appInfos->getFile() . " has been updated.");
}
$installer = new \Jelix\Installer\Installer(new \Jelix\Installer\Reporter\Console('warning'));
$installer->installEntryPoint($name . ".php");
if ($this->verbose()) {
$output->writeln("All modules have been initialized for the new entry point.");
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$appPath = $input->getArgument('path');
$appPath = Path::normalizePath($appPath, 0, getcwd());
$appName = basename($appPath);
$appPath .= '/';
if (file_exists($appPath . '/jelix-app.json') || file_exists($appPath . '/project.xml')) {
throw new \Exception("this application is already created");
}
$this->prepareSubCommandApp($appName, $appPath);
App::setEnv('jelix-scripts');
\Jelix\DevHelper\JelixScript::checkTempPath();
if ($p = $input->getOption('wwwpath')) {
$wwwpath = Path::shortestPath($appPath, $p) . '/';
} else {
$wwwpath = App::wwwPath();
}
if ($output->isVerbose()) {
$output->writeln("Create directories and files at {$appPath}");
}
$param = $this->_createSkeleton($appPath, $appName, $wwwpath, $input);
App::declareModulesDir(array($appPath . '/modules/'));
$installer = new \Jelix\Installer\Installer(new \Jelix\Installer\Reporter\Console($output->isVerbose() ? 'notice' : 'warning'));
$installer->installApplication();
$moduleok = true;
if (!$input->getOption('nodefaultmodule')) {
try {
if ($output->isVerbose()) {
$output->writeln("Create default module " . $param['modulename']);
}
$options = array('module' => $param['modulename'], '--addinstallzone' => true, '--noregistration' => true);
if ($output->isVerbose()) {
$options['-v'] = true;
}
$this->executeSubCommand('module:create', $options, $output);
if ($output->isVerbose()) {
$output->writeln("Create main template");
}
$this->createFile($appPath . 'modules/' . $param['modulename'] . '/templates/main.tpl', 'module/main.tpl.tpl', $param, "Main template");
} catch (\Exception $e) {
$moduleok = false;
$output->writeln("<error>The module has not been created because of this error: " . $e->getMessage() . "</error>");
$output->writeln("However the application has been created");
}
}
if ($input->getOption('withcmdline')) {
if (!$input->getOption('nodefaultmodule') && $moduleok) {
if ($output->isVerbose()) {
$output->writeln("Create a controller in the default module for the cli script");
}
$options = array('module' => $param['modulename'], 'controller' => 'default', 'method' => 'index', '--cmdline' => true);
if ($output->isVerbose()) {
$options['-v'] = true;
}
$this->executeSubCommand('module:createctrl', $options, $output);
}
if ($output->isVerbose()) {
$output->writeln("Create the cli script");
}
$options = array('entrypoint' => $param['modulename'], '--type' => 'cmdline');
if ($output->isVerbose()) {
$options['-v'] = true;
}
$this->executeSubCommand('app:createentrypoint', $options, $output);
}
}
public function run()
{
$appPath = $this->getParam('path');
$appPath = $this->getRealPath($appPath);
$appName = basename($appPath);
$appPath .= '/';
if (file_exists($appPath . '/jelix-app.json') || file_exists($appPath . '/project.xml')) {
throw new Exception("this application is already created");
}
$this->config = JelixScript::loadConfig($appName);
$this->config->infoWebsite = $this->config->newAppInfoWebsite;
$this->config->infoLicence = $this->config->newAppInfoLicence;
$this->config->infoLicenceUrl = $this->config->newAppInfoLicenceUrl;
$this->config->infoLocale = $this->config->newAppInfoLocale;
$this->config->infoCopyright = $this->config->newAppInfoCopyright;
$this->config->initAppPaths($appPath);
App::setEnv('jelix-scripts');
JelixScript::checkTempPath();
if ($p = $this->getOption('-wwwpath')) {
$wwwpath = path::real($appPath . $p, false) . '/';
} else {
$wwwpath = App::wwwPath();
}
$this->createDir($appPath);
$this->createDir(App::tempBasePath());
$this->createDir($wwwpath);
$varPath = App::varPath();
$configPath = App::configPath();
$this->createDir($varPath);
$this->createDir(App::logPath());
$this->createDir($configPath);
$this->createDir($configPath . 'index/');
$this->createDir($varPath . 'overloads/');
$this->createDir($varPath . 'themes/');
$this->createDir($varPath . 'themes/default/');
$this->createDir($varPath . 'uploads/');
$this->createDir($varPath . 'sessions/');
$this->createDir($varPath . 'mails/');
$this->createDir($appPath . 'install');
$this->createDir($appPath . 'modules');
$this->createDir($appPath . 'plugins');
$this->createDir($appPath . 'responses');
$this->createDir($appPath . 'tests');
$this->createDir(App::scriptsPath());
$param = array();
if ($this->getOption('-nodefaultmodule')) {
$param['tplname'] = 'jelix~defaultmain';
$param['modulename'] = 'jelix';
} else {
$moduleName = $this->getOption('-modulename');
if (!$moduleName) {
// note: since module name are used for name of generated name,
// only this characters are allowed
$moduleName = preg_replace('/([^a-zA-Z_0-9])/', '_', $appName);
}
$param['modulename'] = $moduleName;
$param['tplname'] = $moduleName . '~main';
}
$param['config_file'] = 'index/config.ini.php';
$param['rp_temp'] = $this->getRelativePath($appPath, App::tempBasePath());
$param['rp_var'] = $this->getRelativePath($appPath, App::varPath());
$param['rp_log'] = $this->getRelativePath($appPath, App::logPath());
$param['rp_conf'] = $this->getRelativePath($appPath, $configPath);
$param['rp_www'] = $this->getRelativePath($appPath, $wwwpath);
$param['rp_cmd'] = $this->getRelativePath($appPath, App::scriptsPath());
$param['rp_jelix'] = $this->getRelativePath($appPath, JELIX_LIB_PATH);
$param['rp_vendor'] = '';
foreach (array(LIB_PATH . 'vendor/', LIB_PATH . '../vendor/', LIB_PATH . '../../../') as $path) {
if (file_exists($path)) {
$param['rp_vendor'] = $this->getRelativePath($appPath, realpath($path) . '/');
break;
}
}
$param['rp_app'] = $this->getRelativePath($wwwpath, $appPath);
$this->createFile(App::logPath() . '.dummy', 'dummy.tpl', array());
$this->createFile(App::varPath() . 'mails/.dummy', 'dummy.tpl', array());
$this->createFile(App::varPath() . 'sessions/.dummy', 'dummy.tpl', array());
$this->createFile(App::varPath() . 'overloads/.dummy', 'dummy.tpl', array());
$this->createFile(App::varPath() . 'themes/default/.dummy', 'dummy.tpl', array());
$this->createFile(App::varPath() . 'uploads/.dummy', 'dummy.tpl', array());
$this->createFile($appPath . 'plugins/.dummy', 'dummy.tpl', array());
$this->createFile(App::scriptsPath() . '.dummy', 'dummy.tpl', array());
$this->createFile(App::tempBasePath() . '.dummy', 'dummy.tpl', array());
$this->createFile($appPath . '.htaccess', 'htaccess_deny', $param, "Configuration file for Apache");
$this->createFile($appPath . '.gitignore', 'git_ignore.tpl', $param, ".gitignore");
$this->createFile($appPath . 'jelix-app.json', 'jelix-app.json.tpl', $param, "Project description file");
$this->createFile($appPath . 'composer.json', 'composer.json.tpl', $param, "Composer file");
$this->createFile($appPath . 'cmd.php', 'cmd.php.tpl', $param, "Script for developer commands");
$this->createFile($configPath . 'mainconfig.ini.php', 'var/config/mainconfig.ini.php.tpl', $param, "Main configuration file");
$this->createFile($configPath . 'localconfig.ini.php.dist', 'var/config/localconfig.ini.php.tpl', $param, "Configuration file for specific environment");
$this->createFile($configPath . 'profiles.ini.php', 'var/config/profiles.ini.php.tpl', $param, "Profiles file");
$this->createFile($configPath . 'profiles.ini.php.dist', 'var/config/profiles.ini.php.tpl', $param, "Profiles file for your repository");
$this->createFile($configPath . 'preferences.ini.php', 'var/config/preferences.ini.php.tpl', $param, "Preferences file");
$this->createFile($configPath . 'urls.xml', 'var/config/urls.xml.tpl', $param, "URLs mapping file");
$this->createFile($configPath . 'index/config.ini.php', 'var/config/index/config.ini.php.tpl', $param, "Entry point configuration file");
$this->createFile($appPath . 'responses/myHtmlResponse.class.php', 'responses/myHtmlResponse.class.php.tpl', $param, "Main response class");
$this->createFile($appPath . 'install/installer.php', 'installer/installer.php.tpl', $param, "Installer script");
$this->createFile($appPath . 'tests/runtests.php', 'tests/runtests.php', $param, "Tests script");
$temp = dirname(rtrim(App::tempBasePath(), '/'));
if ($temp != rtrim($appPath, '/')) {
if (file_exists($temp . '/.gitignore')) {
$gitignore = file_get_contents($temp . '/.gitignore') . "\n" . $appName . "/*\n";
file_put_contents($temp . '/.gitignore', $gitignore);
} else {
file_put_contents($temp . '/.gitignore', $appName . "/*\n");
}
} else {
$gitignore = file_get_contents($appPath . '.gitignore') . "\n" . basename(rtrim(App::tempBasePath(), '/')) . "/*\n";
file_put_contents($appPath . '.gitignore', $gitignore);
}
$this->createFile($wwwpath . 'index.php', 'www/index.php.tpl', $param, "Main entry point");
$this->createFile($wwwpath . '.htaccess', 'htaccess_allow', $param, "Configuration file for Apache");
$param['php_rp_temp'] = $this->convertRp($param['rp_temp']);
$param['php_rp_var'] = $this->convertRp($param['rp_var']);
$param['php_rp_log'] = $this->convertRp($param['rp_log']);
$param['php_rp_conf'] = $this->convertRp($param['rp_conf']);
$param['php_rp_www'] = $this->convertRp($param['rp_www']);
$param['php_rp_cmd'] = $this->convertRp($param['rp_cmd']);
$param['php_rp_jelix'] = $this->convertRp($param['rp_jelix']);
if ($param['rp_vendor']) {
$param['php_rp_vendor'] = $this->convertRp($param['rp_vendor']);
$this->createFile($appPath . 'application.init.php', 'application2.init.php.tpl', $param, "Bootstrap file");
} else {
$this->createFile($appPath . 'application.init.php', 'application.init.php.tpl', $param, "Bootstrap file");
}
$installer = new \Jelix\Installer\Installer(new \Jelix\Installer\Reporter\Console('warning'));
$installer->installApplication();
$moduleok = true;
if (!$this->getOption('-nodefaultmodule')) {
try {
$cmd = JelixScript::getCommand('createmodule', $this->config);
$options = $this->getCommonActiveOption();
$options['-addinstallzone'] = true;
$options['-noregistration'] = true;
$cmd->initOptParam($options, array('module' => $param['modulename']));
$cmd->run();
$this->createFile($appPath . 'modules/' . $param['modulename'] . '/templates/main.tpl', 'module/main.tpl.tpl', $param, "Main template");
} catch (Exception $e) {
$moduleok = false;
echo "The module has not been created because of this error: " . $e->getMessage() . "\nHowever the application has been created\n";
}
}
if ($this->getOption('-withcmdline')) {
if (!$this->getOption('-nodefaultmodule') && $moduleok) {
$agcommand = JelixScript::getCommand('createctrl', $this->config);
$options = $this->getCommonActiveOption();
$options['-cmdline'] = true;
$agcommand->initOptParam($options, array('module' => $param['modulename'], 'name' => 'default', 'method' => 'index'));
$agcommand->run();
}
$agcommand = JelixScript::getCommand('createentrypoint', $this->config);
$options = $this->getCommonActiveOption();
$options['-type'] = 'cmdline';
$parameters = array('name' => $param['modulename']);
$agcommand->initOptParam($options, $parameters);
$agcommand->run();
}
}
