PHP ModuleEvent::getTarget方法代码示例

 /**
  * @param ModuleEvent $event
  * @throws Exception
  */
 public function onMergeConfig(ModuleEvent $event)
 {
     // do not parse annotations if config cache is enabled.
     $config = $event->getConfigListener()->getMergedConfig(false);
     $annotationReader = AnnotationReaderFactory::factory($config['zf_annotation']);
     $parser = ClassParserFactory::factory($config, $event->getTarget()->getEventManager(), $annotationReader);
     $scanner = new DirectoryScanner();
     $classesToParse = [];
     $modules = $event->getTarget()->getLoadedModules();
     $modulesAllowedToScan = $config['zf_annotation']['scan_modules'];
     foreach ($modules as $module) {
         $parts = explode('\\', get_class($module));
         $modName = array_shift($parts);
         if (!empty($modulesAllowedToScan) && !in_array($modName, $modulesAllowedToScan)) {
             continue;
         }
         $ref = new ReflectionClass($module);
         $dir = dirname($ref->getFileName());
         foreach ($scanner->scan($dir) as $class) {
             $classesToParse[] = $class;
         }
     }
     $parsedConfig = $parser->parse($classesToParse);
     $event->getConfigListener()->setMergedConfig(array_replace_recursive($parsedConfig, $config));
 }

 /**
  * @param ModuleEvent $e
  * @eturn void
  */
 public function __invoke(ModuleEvent $e)
 {
     $module = $e->getModule();
     if (!$module instanceof InitProviderInterface && !method_exists($module, 'init')) {
         return;
     }
     $module->init($e->getTarget());
 }

 /**
  * @param  ModuleEvent $e
  * @return void
  */
 public function __invoke(ModuleEvent $e)
 {
     $module = $e->getModule();
     if (!$module instanceof BootstrapListenerInterface && !method_exists($module, 'onBootstrap')) {
         return;
     }
     $moduleManager = $e->getTarget();
     $events = $moduleManager->getEventManager();
     $sharedEvents = $events->getSharedManager();
     $sharedEvents->attach('Zend\\Mvc\\Application', MvcEvent::EVENT_BOOTSTRAP, array($module, 'onBootstrap'));
 }

 /**
  * Pass self to the ModuleEvent object early so everyone has access. 
  * 
  * @param ModuleEvent $e 
  * @return ConfigListener
  */
 public function loadModulesPre(ModuleEvent $e)
 {
     if ($this->getOptions()->getConfigCacheEnabled()) {
         $this->getOptions()->setConfigCacheKey(implode('.', $e->getTarget()->getModules()) . '.' . $this->getOptions()->getConfigCacheKey());
         if ($this->hasCachedConfig()) {
             $this->skipConfig = true;
             $this->setMergedConfig($this->getCachedConfig());
         }
     }
     return parent::loadModulesPre($e);
 }

 /**
  * 
  * @param ModuleEvent $event
  */
 public function onMergeConfig(ModuleEvent $event)
 {
     $config = $event->getConfigListener()->getMergedConfig(false);
     $modules = $event->getTarget()->getLoadedModules();
     foreach ($modules as $module) {
         $ref = new ReflectionClass($module);
         $dir = dirname($ref->getFileName()) . '/view';
         if (!is_dir($dir)) {
             continue;
         }
         if (!isset($config['view_manager']['template_path_stack'])) {
             $config['view_manager']['template_path_stack'] = array();
         }
         $config['view_manager']['template_path_stack'][] = $dir;
     }
     $event->getConfigListener()->setMergedConfig($config);
 }

 /**
  * @param ModuleEvent $event
  * @return ConfigListener
  */
 public function onMergeConfig(ModuleEvent $event)
 {
     $configListener = $event->getConfigListener();
     $config = $configListener->getMergedConfig(false);
     $loadedModules = $event->getTarget()->getLoadedModules();
     $loadUthandoConfigs = isset($config['load_uthando_configs']) ? $config['load_uthando_configs'] : false;
     $uthandoConfig = [];
     if (false === $loadUthandoConfigs) {
         return $this;
     }
     // get the configurations from each module
     // must return an array to merge
     foreach ($loadedModules as $module) {
         if ($module instanceof ConfigInterface) {
             $moduleConfig = $module->getUthandoConfig();
             $uthandoConfig = ArrayUtils::merge($uthandoConfig, $moduleConfig);
         }
     }
     $config = ArrayUtils::merge($config, $uthandoConfig);
     // Pass the changed configuration back to the listener:
     $configListener->setMergedConfig($config);
     return $this;
 }

 /**
  * 
  * @param ModuleEvent $event
  */
 public function onMergeConfig(ModuleEvent $event)
 {
     $config = $event->getConfigListener()->getMergedConfig(false);
     $modules = $event->getTarget()->getLoadedModules();
     foreach ($modules as $module) {
         $ref = new ReflectionClass($module);
         $dir = dirname($ref->getFileName()) . '/language';
         if (!is_dir($dir)) {
             continue;
         }
         $iterator = new \DirectoryIterator($dir);
         foreach ($iterator as $file) {
             if ($file->isFile()) {
                 list($domain, $locale, $type) = explode('.', $file->getFilename());
                 if ($type === 'php') {
                     $type = 'phparray';
                 }
                 $config['translator']['translation_files'][] = array('type' => $type, 'filename' => $file->getPathname(), 'text_domain' => $domain, 'locale' => $locale);
             }
         }
     }
     $event->getConfigListener()->setMergedConfig($config);
 }

 /**
  * loadModules
  *
  * Once all the modules are loaded, loop
  *
  * @param  ModuleEvent $e
  * @return void
  */
 public function onLoadModules(ModuleEvent $e)
 {
     $moduleManager = $e->getTarget();
     $events = $moduleManager->getEventManager()->getSharedManager();
     if (!$events) {
         return;
     }
     // Shared instance for module manager
     $events->attach('Zend\\Mvc\\Application', ModuleManager::EVENT_BOOTSTRAP, function (MvcEvent $e) use($moduleManager) {
         $moduleClassName = get_class($moduleManager);
         $moduleClassNameArray = explode('\\', $moduleClassName);
         $moduleClassNameAlias = end($moduleClassNameArray);
         $application = $e->getApplication();
         $services = $application->getServiceManager();
         if (!$services->has($moduleClassName)) {
             $services->setAlias($moduleClassName, $moduleClassNameAlias);
         }
     }, 1000);
     if (0 === count($this->modules)) {
         return;
     }
     // Attach to the bootstrap event if there are modules we need to process
     $events->attach('Zend\\Mvc\\Application', ModuleManager::EVENT_BOOTSTRAP, [$this, 'onBootstrap'], 1000);
 }

 /**
  * @param  ModuleEvent $e
  * @return void
  */
 public function __invoke(ModuleEvent $e)
 {
     // The modules have been loaded
     $target = $e->getTarget();
     if (!$target instanceof ModuleManagerInterface) {
         return;
     }
     $configListener = $e->getConfigListener();
     $config = $configListener->getMergedConfig(false);
     $modules = $target->getModules();
     $adapter = new Adapter($config['db']);
     $sql = new Sql($adapter);
     $select = $sql->select('modules');
     $select->columns(['name']);
     $select->where(['active' => true]);
     $select->order('order DESC');
     $statement = $sql->prepareStatementForSqlObject($select);
     $result = $statement->execute();
     if ($result instanceof ResultInterface && $result->isQueryResult() && $result->getAffectedRows()) {
         while ($current = $result->current()) {
             if (!in_array($current['name'], $modules)) {
                 $target->loadModule($current['name']);
                 $modules[] = $current['name'];
                 $module = $target->getModule($current['name']);
                 if ($module instanceof ConfigProviderInterface || is_callable([$module, 'getConfig'])) {
                     // Merge the config
                     $moduleConfig = $module->getConfig();
                     $config = ArrayUtils::merge($config, $moduleConfig);
                 }
             }
             $result->next();
         }
         $target->setModules($modules);
         $configListener->setMergedConfig($config);
     }
 }

 /**
  * 
  * @param ModuleEvent $event
  */
 public function onMergeConfig(ModuleEvent $event)
 {
     $config = $event->getConfigListener()->getMergedConfig(false);
     $modules = $event->getTarget()->getLoadedModules();
     foreach ($modules as $module) {
         $ref = new ReflectionClass($module);
         $dir1 = dirname($ref->getFileName()) . '/Entity';
         $dir2 = dirname($ref->getFileName()) . '/src/Entity';
         $dirs = array_filter([$dir1, $dir2], 'is_dir');
         if (count($dirs) == 0) {
             continue;
         }
         $dir = current($dirs);
         $parts = explode('\\', get_class($module));
         $moduleName = array_shift($parts);
         if (in_array($moduleName, $this->ignoreModules)) {
             continue;
         }
         $driverName = strtolower($moduleName) . '_entities';
         $config['doctrine']['driver']['orm_default']['drivers'][sprintf('%s\\Entity', $moduleName)] = $driverName;
         $config['doctrine']['driver'][$driverName] = array('class' => 'Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver', 'cache' => 'array', 'paths' => array($dir));
     }
     $event->getConfigListener()->setMergedConfig($config);
 }

 /**
  * @param ModuleEvent $e
  * @return void
  */
 public function __invoke(ModuleEvent $e)
 {
     $module = $e->getModule();
     if (!$module instanceof ThemeProviderInterface && !method_exists($module, 'initTheme')) {
         return;
     }
     $moduleManager = $e->getTarget();
     $events = $moduleManager->getEventManager();
     $sharedEvents = $events->getSharedManager();
     $module_directory = $module->getDir();
     $sharedEvents->attach('Zend\\Mvc\\Application', MvcEvent::EVENT_BOOTSTRAP, function ($e) use($module_directory) {
         $application = $e->getApplication();
         $eventManager = $application->getEventManager();
         $serviceManager = $application->getServiceManager();
         $themeManager = $serviceManager->get('ThemeManager');
         $theme = $themeManager->getTheme();
         $theme_folder = $theme->getFolder();
         $theme_path = $module_directory . '/themes/' . $theme_folder;
         if (!is_dir($theme_path)) {
             $theme = $themeManager->getDefaultTheme();
             $theme_folder = $theme->getFolder();
             if (!is_dir($theme_path)) {
                 throw new MissingDefaultThemeException();
             }
         }
         $theme_path = $module_directory . '/themes/' . $theme->getFolder();
         // Views
         // Add the folder to the template resolver.
         $templatePathResolver = $serviceManager->get('Zend\\View\\Resolver\\TemplatePathStack');
         $templatePathResolver->addPath($theme_path);
         // Layout
         if (file_exists($theme_path . '/layout.phtml')) {
             $templateMapResolver = $serviceManager->get('Zend\\View\\Resolver\\TemplateMapResolver');
             $layout_name = $theme->getLayoutName();
             if (!$templateMapResolver->has($layout_name)) {
                 $templateMapResolver->add($layout_name, $theme_path . '/layout.phtml');
             }
         }
     });
     $sharedEvents->attach($module->getNamespace(), MvcEvent::EVENT_DISPATCH, function ($e) use($module_directory) {
         // Set the layout for this module if available
         $serviceManager = $e->getApplication()->getServiceManager();
         $themeManager = $serviceManager->get('ThemeManager');
         $theme = $themeManager->getTheme();
         $theme_folder = $theme->getFolder();
         $theme_path = $module_directory . '/themes/' . $theme_folder;
         if (!is_dir($theme_path)) {
             $theme = $themeManager->getDefaultTheme();
             $theme_folder = $theme->getFolder();
             if (!is_dir($theme_path)) {
                 throw new MissingDefaultThemeException();
             }
         }
         $layout_name = $theme->getLayoutName();
         $templateMapResolver = $serviceManager->get('Zend\\View\\Resolver\\TemplateMapResolver');
         if ($templateMapResolver->has($layout_name)) {
             $viewModel = $e->getViewModel();
             $viewModel->setTemplate($layout_name);
         }
     }, 100);
 }