/**
* Handle annotation creation
*
* @param EventInterface $e
* @return false|\stdClass
*/
public function onCreateAnnotation(EventInterface $e)
{
$annotationClass = $e->getParam('class', false);
if (!$annotationClass) {
return false;
}
if (!isset($this->allowedAnnotations[$annotationClass])) {
return false;
}
$annotationString = $e->getParam('raw', false);
if (!$annotationString) {
return false;
}
// Annotation classes provided by the AnnotationScanner are already
// resolved to fully-qualified class names. Adding the global namespace
// prefix allows the Doctrine annotation parser to locate the annotation
// class correctly.
$annotationString = preg_replace('/^(@)/', '$1\\', $annotationString);
$parser = $this->getDocParser();
$annotations = $parser->parse($annotationString);
if (empty($annotations)) {
return false;
}
$annotation = array_shift($annotations);
if (!is_object($annotation)) {
return false;
}
return $annotation;
}
/**
* Handle event. Add config values
*
* @param EventInterface $event
* @return EventInterface
*/
public function onSearchPre(EventInterface $event)
{
$backend = $event->getTarget();
if ($backend === $this->backend) {
$params = $event->getParam('params');
if ($params) {
// Set highlighting parameters unless explicitly disabled:
$hl = $params->get('hl');
if (!isset($hl[0]) || $hl[0] != 'false') {
// Add hl.q for non query events
if (!$event->getParam('query', false)) {
$lastSearch = $this->memory->retrieve();
if ($lastSearch) {
$urlParams = parse_url($lastSearch);
parse_str($urlParams['query'], $queryParams);
if (isset($queryParams['lookfor'])) {
$params->set('hl.q', '*:"' . addslashes($queryParams['lookfor']) . '"');
}
}
}
// All all highlight config fields
foreach ($this->config as $key => $value) {
$params->set('hl.' . $key, $value);
}
}
}
}
return $event;
}
/**
* @param array|null $resource
* @param Request $request
* @param Response $response
*/
public function __invoke(EventInterface $event)
{
$resource = $event->getParam('resource');
$request = $event->getParam('request');
$formattedResource = $this->formatter->format($resource, $request->params());
$event->setParam('resource', $formattedResource);
}
public function handleOneToOneAnnotation(EventInterface $event)
{
$annotation = $event->getParam('annotation');
if (!$annotation instanceof OneToOne) {
return;
}
$spec = $event->getParam('spec');
$spec['oneToOne'] = $annotation->getName();
}
public function handleManyToManyAnnotation(EventInterface $event)
{
$annotation = $event->getParam('annotation');
if (!$annotation instanceof Annotation\ManyToMany) {
return;
}
$spec = $event->getParam('spec');
$spec['manyToMany'] = $annotation->getName();
}
public function onBootstrap(EventInterface $e)
{
/* @var $application \Zend\Mvc\Application */
$application = $e->getTarget();
$eventManager = $application->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
//todo Delete this hack (avoid unit tests) after update BjyAuthorize module to 2.0
if (\Zend\Console\Console::isConsole()) {
return;
}
$sm = $e->getApplication()->getServiceManager();
// Add ACL information to the Navigation view helper
$authorize = $sm->get('BjyAuthorizeServiceAuthorize');
$acl = $authorize->getAcl();
$role = $authorize->getIdentity();
ZendViewHelperNavigation::setDefaultAcl($acl);
ZendViewHelperNavigation::setDefaultRole($role);
$services = $application->getServiceManager();
$zfcServiceEvents = $services->get('zfcuser_user_service')->getEventManager();
$zfcServiceEvents->attach('register', function ($e) use($services) {
$zfcUser = $e->getParam('user');
$em = $services->get('doctrine.entitymanager.orm_default');
$configAuth = $services->get('BjyAuthorize\\Config');
$providerConfig = $configAuth['role_providers']['BjyAuthorize\\Provider\\Role\\ObjectRepositoryProvider'];
$criteria = array('roleId' => $configAuth['authenticated_role']);
$defaultUserRole = $em->getRepository($providerConfig['role_entity_class'])->findOneBy($criteria);
if ($defaultUserRole !== null) {
$zfcUser->addRole($defaultUserRole);
}
});
$application->getEventManager()->getSharedManager()->attach('ZfcUserAdmin\\Form\\EditUser', 'init', function ($e) {
// $form is a ZfcUser\Form\Register
$form = $e->getTarget();
$sm = $form->getServiceManager();
$om = $sm->get('Doctrine\\ORM\\EntityManager');
//$form->setHydrator(new \DoctrineORMModule\Stdlib\Hydrator\DoctrineEntity($om, 'OpsWay\TocatUser\Entity\User'));
$form->add(array('name' => 'roles', 'type' => 'DoctrineModule\\Form\\Element\\ObjectMultiCheckbox', 'options' => array('label' => 'Assign Roles', 'object_manager' => $om, 'target_class' => Entity\Role::class, 'property' => 'roleId')));
$form->add(array('name' => 'groups', 'type' => 'DoctrineModule\\Form\\Element\\ObjectSelect', 'options' => array('label' => 'Assign Groups', 'object_manager' => $om, 'target_class' => Entity\Group::class, 'property' => 'name'), 'attributes' => array('multiple' => true)));
});
$application->getEventManager()->getSharedManager()->attach('ZfcUserAdmin\\Service\\User', 'edit', function ($e) {
$zfcUser = $e->getParam('user');
$post = $e->getParam('data');
$em = $e->getParam('form')->getServiceManager()->get('doctrine.entitymanager.orm_default');
$listRoles = $em->getRepository(Entity\Role::class)->findBy(array('id' => $post['roles']));
$zfcUser->updateRoles($listRoles);
$listGroup = $em->getRepository(Entity\Group::class)->findBy(array('id' => $post['groups']));
$zfcUser->updateGroups($listGroup);
});
}
/**
* Event handler for missing translations
*
* @param \Zend\EventManager\EventInterface $e
*/
public function onMissingTranslation(\Zend\EventManager\EventInterface $e)
{
// Issue warning about missing translation for the 'default' text
// domain. This warning will indicate either a message string missing in
// the translation file, or accidental translator invokation when a
// string should not actually be translated.
// If a fallback locale is involved, suppress the warning for the
// standard locale.
$fallbackLocale = $e->getTarget()->getFallbackLocale();
if ((!$fallbackLocale or $e->getParam('locale') == $fallbackLocale) and $e->getParam('text_domain') == 'default') {
trigger_error('Missing translation: ' . $e->getParam('message'), E_USER_NOTICE);
// @codeCoverageIgnoreStart
}
// @codeCoverageIgnoreEnd
}
/**
* Add current `DateTime` value for field `last_updated_at`
*
* @param EventInterface $event
*/
public function onUpdate(EventInterface $event)
{
$values = $event->getParam('values');
$now = new DateTime();
$values['last_updated_at'] = $now->format('Y-m-d h:i:s');
$event->setParam('values', $values);
}
/**
* Inject Form defined by type to BlogService when triggered
*
* @param EventInterface
*/
public function onFormSet(EventInterface $e)
{
$type = $e->getParam('type', 'create');
$service = $this->serviceLocator->get('Blog\\Service\\Blog');
$form = $this->serviceLocator->get('Blog\\Form\\' . ucfirst($type));
$service->setForm($form, $type);
}
/**
* {@inheritDoc}
*/
public function onBootstrap(EventInterface $e)
{
/** @var $application \Zend\Mvc\Application */
$application = $e->getParam('application');
$listener = $application->getServiceManager()->get('StrokerCache\\Listener\\CacheListener');
$application->getEventManager()->attach($listener);
}
public function onRenderEntity(EventInterface $event)
{
$halEntity = $event->getParam('entity');
$link = new \ZF\Hal\Link\Link('search');
$link->setUrl('http://www.google.com/?q=thing' . $halEntity->entity->getId());
$halEntity->getLinks()->add($link);
}
/**
* @param EventInterface $event
*/
public function __invoke(EventInterface $event)
{
/** @var Message $message */
$message = $event->getParam('message');
/** @var Template $template */
$template = $event->getParam('template');
/** @var \Zend\Mail\AddressList $toAddress */
$toAddress = $message->getTo();
$toAddress->rewind();
$fromAddress = $message->getFrom();
$fromAddress->rewind();
/** @var \Zend\Mime\Message $body */
$body = $message->getBody();
$entry = new MailLogEntry(['mailFrom' => $fromAddress->current()->getEmail(), 'mailTo' => $toAddress->current()->getEmail(), 'subject' => $message->getSubject(), 'layoutId' => $template->getLayoutId(), 'templateId' => $template->getId(), 'body' => $body->getPartContent(0), 'calculatedVars' => json_encode($event->getParam('data'))]);
$this->logRepository->add($entry);
}
public function onAfterSimpleMailerSend(EventInterface $event)
{
/** @var \Detail\Mail\Service\MailerInterface $mailer */
$mailer = $event->getTarget();
$message = $event->getParam('message');
if ($message === null) {
throw new RuntimeException(sprintf('Event "%s" is missing param "message"', $event->getName()));
} elseif (!$message instanceof MessageInterface) {
throw new RuntimeException(sprintf('Event "%s" has invalid value for param "message"; ' . 'expected Detail\\Mail\\Message\\MessageInterface object but got ' . is_object($message) ? get_class($message) : gettype($message), $event->getName()));
}
$headersText = preg_replace('/\\s+/', ' ', str_replace(PHP_EOL, ' ', var_export($message->getHeaders(), true)));
if ($mailer instanceof SimpleMailer) {
/** @var \Detail\Mail\Service\SimpleMailer $mailer */
$driverClass = get_class($mailer->getDriver());
switch ($driverClass) {
case 'Detail\\Mail\\Driver\\Bernard\\BernardDriver':
$text = 'Queued email message "%s" of type "%s" (headers: "%s", driver: %s)';
break;
default:
$text = 'Sent email message "%s" of type "%s" (headers: "%s", driver: %s)';
break;
}
$text = sprintf($text, $message->getId(), $message->getName(), $headersText, $driverClass);
} else {
$text = sprintf('Sent email message "%s" of type "%s" (headers: "%s")', $message->getId(), $message->getName(), $headersText);
}
$this->log($text);
}
/**
* Set up spelling parameters.
*
* @param EventInterface $event Event
*
* @return EventInterface
*/
public function onSearchPre(EventInterface $event)
{
$backend = $event->getTarget();
if ($backend === $this->backend) {
$params = $event->getParam('params');
if ($params) {
// Set spelling parameters unless explicitly disabled:
$sc = $params->get('swissbibspellcheck');
if (!empty($sc) && $sc[0] != 'false') {
//remove the homegrown parameter only needed to activate
// the spellchecker in case of zero hits
$params->remove("swissbibspellcheck");
$this->active = true;
if (empty($this->dictionaries)) {
throw new \Exception('Spellcheck requested but no dictionary configured');
}
// Set relevant Solr parameters:
reset($this->dictionaries);
$params->set('spellcheck', 'true');
$params->set('spellcheck.dictionary', current($this->dictionaries));
// Turn on spellcheck.q generation in query builder:
$this->backend->getQueryBuilder()->setCreateSpellingQuery(true);
}
}
}
return $event;
}
/**
* {@inheritDoc}
*/
public function onBootstrap(EventInterface $e)
{
/* @var $app \Zend\Mvc\ApplicationInterface */
$app = $e->getTarget();
$events = $app->getEventManager()->getSharedManager();
// Attach to helper set event and load the entity manager helper.
$events->attach('doctrine', 'loadCli.post', function (EventInterface $e) {
/* @var $cli \Symfony\Component\Console\Application */
$cli = $e->getTarget();
ConsoleRunner::addCommands($cli);
$cli->addCommands(array(new DiffCommand(), new ExecuteCommand(), new GenerateCommand(), new MigrateCommand(), new StatusCommand(), new VersionCommand()));
/* @var $sm ServiceLocatorInterface */
$sm = $e->getParam('ServiceManager');
/* @var $em \Doctrine\ORM\EntityManager */
$em = $sm->get('doctrine.entitymanager.orm_default');
$helperSet = $cli->getHelperSet();
$helperSet->set(new DialogHelper(), 'dialog');
$helperSet->set(new ConnectionHelper($em->getConnection()), 'db');
$helperSet->set(new EntityManagerHelper($em), 'em');
});
$config = $app->getServiceManager()->get('Config');
$app->getServiceManager()->get('doctrine.entity_resolver.orm_default');
if (isset($config['zenddevelopertools']['profiler']['enabled']) && $config['zenddevelopertools']['profiler']['enabled']) {
$app->getServiceManager()->get('doctrine.sql_logger_collector.orm_default');
}
}
/**
* Listen to the bootstrap event
*
* @param EventInterface $e
*
* @return array
*/
public function onBootstrap(EventInterface $e)
{
$app = $e->getParam('application');
$em = $app->getEventManager();
$em->attach(MvcEvent::EVENT_DISPATCH, function ($event) {
$event->getApplication()->getServiceManager()->get(AffiliationNavigationService::class)->update();
});
}
/**
* Inject Table defined by type to PizzaService when triggered
*
* @param EventInterface
*/
public function onTableSet(EventInterface $e)
{
$type = $e->getParam('type', 'rentals');
$tableName = StaticFilter::execute($type, 'wordunderscoretocamelcase');
$service = $this->serviceLocator->get('Rentals\\Service\\Rentals');
$form = $this->serviceLocator->get('Rentals\\Table\\' . $tableName);
$service->setTable($form, $type);
}
/**
* Listen to the bootstrap event
*
* @param EventInterface $e
*
* @return array
*/
public function onBootstrap(EventInterface $e)
{
$app = $e->getParam('application');
$em = $app->getEventManager();
$em->attach(MvcEvent::EVENT_DISPATCH, function ($event) {
$event->getApplication()->getServiceManager()->get('program_nda_navigation_service')->update();
});
}
/**
* Discover the fallback name via reflection
*
* @param \Zend\EventManager\EventInterface $e
* @return string
*/
public function discoverFallbackName($e)
{
$reflection = $e->getParam('reflection');
if ($reflection instanceof ReflectionClass) {
return $reflection->getShortName();
}
return $reflection->getName();
}
/**
* @param \Zend\EventManager\EventInterface $e
*/
public function handleAllowEmpty($e)
{
$formSpec = $e->getParam('formSpec');
if (!(isset($formSpec['object']) && $this->objectManager->getMetadataFactory()->hasMetadataFor($formSpec['object']))) {
return;
}
$metadata = $this->objectManager->getClassMetadata($formSpec['object']);
$fieldName = $e->getParam('elementSpec')['spec']['name'];
if (!$metadata->hasField($fieldName)) {
return;
}
$fieldMapping = $metadata->getFieldMapping($fieldName);
$inputSpec = $e->getParam('inputSpec');
if (!isset($inputSpec['allow_empty'])) {
$inputSpec['allow_empty'] = $fieldMapping['nullable'];
$e->setParam('inputSpec', $inputSpec);
}
}
/**
* @param EventInterface $e
* @return void
*/
public function handleTitleAnnotation(EventInterface $e)
{
$annotation = $e->getParam('annotation');
if (!$annotation instanceof Title) {
return;
}
$datagridSpec = $e->getParam('datagridSpec');
$datagridSpec['title'] = array('singular' => $annotation->singular, 'plural' => $annotation->plural);
}
public function __invoke(EventInterface $e)
{
$page = $e->getParam('page');
$container = $this->helper->getContainer();
$navPage = $container->findOneBy('route', $page->getId());
if ($navPage instanceof Page) {
$navPage->setActive(true);
}
}
/**
* @{inheritdoc}
*/
public function onBootstrap(EventInterface $e)
{
$app = $e->getParam('application');
$em = $app->getEventManager();
$eventManager = $e->getApplication()->getEventManager();
//$result=$eventManager->attach('route', array($this, 'loadConfigurations'), 2);
$em->attach(MvcEvent::EVENT_DISPATCH, array($this, 'selectLayoutBasedOnRoute'));
$em->attach(MvcEvent::EVENT_DISPATCH, array($this, 'selectLayoutBasedOnRoute1'));
}
public function onReceivedNodeReceipt(EventInterface $e)
{
/** @var NodeInterface $node */
$node = $e->getParam('node');
/** @var Client $client */
$client = $e->getTarget();
$params = ['id' => $node->getAttribute('id'), 'node' => $node];
$client->getEventManager()->trigger('onReceiptClient', $client, $params);
}
/**
* On user registration
*
* @param EventInterface $e
*/
public function onUserRegistration(EventInterface $e)
{
$user = $e->getParam('user');
if ($this->getOptions()->getSendVerificationEmail() && $this->getZfcUserOptions()->getEnableRegistration()) {
$this->sendVerificationEmail($user);
} elseif ($this->getOptions()->getSendPasswordRequestEmail() && !$this->getZfcUserOptions()->getEnableRegistration()) {
$this->sendPasswordRequestEmail($user);
}
}
/**
* Listen to onCreateAnnotation, and attempt to return an annotation object
* instance.
*
* If the annotation class or alias is not registered, immediately returns
* false. Otherwise, resolves the class, clones it, and, if any content is
* present, calls {@link AnnotationInterface::initialize()} with the
* content.
*
* @param EventInterface $e
* @return false|AnnotationInterface
*/
public function onCreateAnnotation(EventInterface $e)
{
$class = $e->getParam('class', false);
if (!$class || !$this->hasAnnotation($class)) {
return false;
}
$content = $e->getParam('content', '');
$content = trim($content, '()');
if ($this->hasAlias($class)) {
$class = $this->resolveAlias($class);
}
$index = array_search($class, $this->annotationNames);
$annotation = $this->annotations[$index];
$newAnnotation = clone $annotation;
if ($content) {
$newAnnotation->initialize($content);
}
return $newAnnotation;
}
/**
* @param EventInterface $event
* @return bool
*/
public function accept(EventInterface $event)
{
// This is the default behavior (allow access, if not otherwise specified)
$accept = true;
$page = $event->getParam('page');
if ($page instanceof AbstractPage && $page->getPermission() !== null) {
$accept = $this->authorizationService->isAllowed($page->getPermission(), $page);
}
return $accept;
}
/**
* @param EventInterface $e
*/
public function handleMappingAnnotation(EventInterface $e)
{
$annotation = $e->getParam('annotation');
if (!$annotation instanceof OneToOne && !$annotation instanceof OneToMany && !$annotation instanceof ManyToOne && !$annotation instanceof ManyToMany) {
return;
}
$elementSpec = $e->getParam('elementSpec');
$options = array('target_class' => $annotation->targetEntity);
if (isset($elementSpec['spec']['options'])) {
if (is_array($elementSpec['spec']['options'])) {
$elementSpec['spec']['options'] = array_merge($elementSpec['spec']['options'], $options);
}
if ($elementSpec['spec']['options'] instanceof ArrayObject) {
$elementSpec['spec']['options'] = array_merge($elementSpec['spec']['options']->getArrayCopy(), $options);
}
} else {
$elementSpec['spec']['options'] = $options;
}
}
/**
* @internal
*/
public function onBootstrap(\Zend\EventManager\EventInterface $e)
{
$eventManager = $e->getParam('application')->getEventManager();
$eventManager->attach(MvcEvent::EVENT_ROUTE, array($this, 'forceLogin'));
$eventManager->attach(MvcEvent::EVENT_RENDER, array($this, 'setStrictVars'));
$eventManager->attach(MvcEvent::EVENT_RENDER, array($this, 'setMenu'));
$eventManager->attach(MvcEvent::EVENT_RENDER, array($this, 'setLayoutTitle'));
$eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, array($this, 'onError'));
$eventManager->attach(MvcEvent::EVENT_RENDER_ERROR, array($this, 'onError'));
}
/**
* @param EventInterface $e
*/
public function onReceivedNode(EventInterface $e)
{
/** @var NodeInterface $node */
$node = $e->getParam('node');
/** @var Client $client */
$client = $e->getTarget();
// triggering public event
$client->getEventManager()->trigger('onLoginFailed', $client, ['node' => $node]);
throw new \RuntimeException("Login failed");
}
