/**
* @return Nette\Application\IResponse
*/
public function run(Application\Request $request)
{
$this->request = $request;
$httpRequest = $this->context->getByType('Nette\\Http\\IRequest');
if (!$httpRequest->isAjax() && ($request->isMethod('get') || $request->isMethod('head'))) {
$refUrl = clone $httpRequest->getUrl();
$url = $this->context->getService('router')->constructUrl($request, $refUrl->setPath($refUrl->getScriptPath()));
if ($url !== NULL && !$httpRequest->getUrl()->isEqual($url)) {
return new Responses\RedirectResponse($url, Http\IResponse::S301_MOVED_PERMANENTLY);
}
}
$params = $request->getParameters();
if (!isset($params['callback'])) {
throw new Application\BadRequestException("Parameter callback is missing.");
}
$params['presenter'] = $this;
$callback = new Nette\Callback($params['callback']);
$response = $callback->invokeArgs(Application\UI\PresenterComponentReflection::combineArgs($callback->toReflection(), $params));
if (is_string($response)) {
$response = array($response, array());
}
if (is_array($response)) {
if ($response[0] instanceof \SplFileInfo) {
$response = $this->createTemplate('Nette\\Templating\\FileTemplate')->setParameters($response[1])->setFile($response[0]);
} else {
$response = $this->createTemplate('Nette\\Templating\\Template')->setParameters($response[1])->setSource($response[0]);
}
}
if ($response instanceof Nette\Templating\ITemplate) {
return new Responses\TextResponse($response);
} else {
return $response;
}
}
/**
* @return MailControl
*/
protected function createComponentForm()
{
/** @var $control MailControl */
$control = $this->mailControlFactory->invoke($this->extendedPage->mailform);
$control->onSuccess[] = $this->formSuccess;
return $control;
}
public function prepareFilters(Template $template)
{
$this->latte = $this->latteFactory->invoke();
foreach ($this->macroFactories as $factory) {
$this->container->{Container::getMethodName($factory, FALSE)}($this->latte->getCompiler());
}
$template->registerFilter($this->latte);
}
public function attached($presenter)
{
parent::attached($presenter);
$this->column = $this->lookup('Brabijan\\Datagrid\\Renderer')->getColumn($this->columnId);
if ($this->templateRowCallback) {
$this->templateRowCallback->invokeArgs(array($this));
}
}
/**
* Setup permission by role
*
* @param Permission $permission
* @param string $role
* @return Permission
*/
protected function setPermissionsByRole(Permission $permission, $role)
{
if ($role == 'admin') {
$permission->allow('admin', Permission::ALL);
return $permission;
}
if ($this->checkConnection->invoke()) {
$roleEntity = $this->roleRepository->findOneByName($role);
if ($roleEntity) {
if ($roleEntity->parent) {
$this->setPermissionsByRole($permission, $roleEntity->parent->name);
}
if ($roleEntity && !$permission->hasRole($role)) {
$permission->addRole($role, $roleEntity->parent ? $roleEntity->parent->name : NULL);
}
// allow/deny
foreach ($roleEntity->permissions as $perm) {
if ($permission->hasResource($perm->resource)) {
if ($perm->allow) {
$permission->allow($role, $perm->resource, $perm->privilege ? $perm->privilege : NULL);
} else {
$permission->deny($role, $perm->resource, $perm->privilege ? $perm->privilege : NULL);
}
}
}
}
}
return $permission;
}
/**
* Asks for confirmation whether to manually follow redirect
* @param Response $response
*
* @return boolean
*/
protected function confirmRedirect(Response $response)
{
if ($this->confirmRedirect !== NULL) {
return (bool) $this->confirmRedirect->invoke($response);
}
return TRUE;
}
/**
* @param $callback
* @return $this
* @throws \movi\InvalidArgumentException
*/
public function setDisabled($callback)
{
if (!is_callable($callback)) {
throw new InvalidArgumentException('Callback is not callable');
}
$this->disabled = Callback::create($callback);
return $this;
}
/**
* @param $helper
* @return callable
* @throws \movi\InvalidArgumentException
*/
public function loader($helper)
{
if (isset($this->helpers[$helper])) {
return Callback::create($this->helpers[$helper], 'process');
} else {
return false;
}
}
/**
* @param null $data
* @return Form
* @throws \Nette\InvalidStateException
*/
public function invoke($data = NULL)
{
if (!$this->factory) {
throw new InvalidStateException('Form factory has not been set');
}
/** @var $form Form */
$form = $this->factory->invoke();
if ($data) {
$form->setData($data);
}
$form->setMapper($this->getMapper());
foreach ($this->getControlExtensions() as $controlExtension) {
$form->addControlExtension($controlExtension);
}
$this->configure($form);
$this->attachHandlers($form);
return $form;
}
/**
* Performs an authentication
*
* @param array
* @return \Nette\Security\Identity
* @throws AuthenticationException
*/
public function authenticate(array $credentials)
{
try {
return parent::authenticate($credentials);
} catch (AuthenticationException $ex) {
list($username, $password) = $credentials;
if ($this->checkConnection->invoke()) {
$user = $this->userRepository->findOneBy(array('email' => $username, 'published' => 1));
if (!$user) {
throw $ex;
}
if (!$user->verifyByPassword($password)) {
throw new AuthenticationException('The password is incorrect.', self::INVALID_CREDENTIAL);
}
return new Identity($user->id, $user->getRoles());
}
throw $ex;
}
}
public function onSuccess(Form $form)
{
if (!Callback::create($this->checkConnection)->invoke() || !$this->schemaManager->tablesExist('users')) {
return;
}
$presenter = $form->presenter;
$logEntity = new LogEntity($this->user instanceof UserEntity ? $this->user : NULL, 'Venne\\Forms\\Form', NULL, LogEntity::ACTION_OTHER);
$logEntity->setType($presenter->link('this'));
$logEntity->setMessage('Configuration has been updated');
$this->logRepository->save($logEntity);
}
public function signalReceived($signal)
{
$query = $this->form->presenter->request->parameters['q'];
if (!$this->suggestCallback) {
throw new InvalidArgumentException("Property 'suggestCallback' is not defined.");
}
$data = Callback::create($this->suggestCallback)->invoke($query);
if (!is_array($data)) {
throw new InvalidArgumentException("Data from suggestCallback must be array.");
}
$this->form->getPresenter()->sendResponse(new JsonResponse(array('results' => $data, 'more' => FALSE)));
}
/**
* Returns mPDF object
* @return mPDFExtended
*/
public function getMPDF() {
if(!$this->mPDF instanceof mPDF) {
if($this->createMPDF instanceof Callback && $this->createMPDF->isCallable()) {
$mpdf = $this->createMPDF->invoke($this);
if(!($mpdf instanceof \mPDF)) {
throw new \Nette\InvalidStateException("Callback function createMPDF must return mPDF object!");
}
$this->mPDF = $mpdf;
}else
throw new \Nette\InvalidStateException("Callback createMPDF is not callable or is not instance of Nette\Callback!");
}
return $this->mPDF;
}
/**
* Logs message or exception to file and sends email notification.
* @param string|array
* @param int one of constant INFO, WARNING, ERROR (sends email), CRITICAL (sends email)
* @return bool was successful?
*/
public function log($message, $priority = self::INFO)
{
if (!is_dir($this->directory)) {
throw new Nette\DirectoryNotFoundException("Directory '{$this->directory}' is not found or is not directory.");
}
if (is_array($message)) {
$message = implode(' ', $message);
}
$res = error_log(trim($message) . PHP_EOL, 3, $this->directory . '/' . strtolower($priority) . '.log');
if (($priority === self::ERROR || $priority === self::CRITICAL) && $this->email && $this->mailer && @filemtime($this->directory . '/email-sent') + self::$emailSnooze < time() && @file_put_contents($this->directory . '/email-sent', 'sent')) {
Nette\Callback::create($this->mailer)->invoke($message, $this->email);
}
return $res;
}
public function render()
{
if ($this->customTemplate === NULL) {
$this->template->setFile(__DIR__ . '/control.latte');
} else {
$this->template->setFile($this->customTemplate);
$this->template->extend = __DIR__ . '/control.latte';
}
$this->template->rows = array_keys($this->getData());
if ($this->isPaginatorEnabled()) {
$this->template->paginationPosition = $this->paginationPositions;
$this->template->paginator = $this->paginator;
} else {
$this->template->paginationPosition = Renderer::PAGINATION_NONE;
}
if ($this->templateHelpersCallback) {
$this->templateHelpersCallback->invokeArgs(array($this->template));
}
$this->template->showFilter = ($this->filterManualRender == FALSE and $this->filterFormFactory !== NULL);
$this->template->showHeaders = !$this->hideDatagridHeaders;
$this->template->render();
}
/**
* __call() implementation.
* @param object
* @param string
* @param array
* @return mixed
* @throws MemberAccessException
*/
public static function call($_this, $name, $args)
{
$class = get_class($_this);
$isProp = self::hasProperty($class, $name);
if ($name === '') {
throw new MemberAccessException("Call to class '{$class}' method without name.");
} elseif ($isProp === 'event') {
// calling event handlers
if (is_array($_this->{$name}) || $_this->{$name} instanceof \Traversable) {
foreach ($_this->{$name} as $handler) {
Nette\Callback::create($handler)->invokeArgs($args);
}
} elseif ($_this->{$name} !== NULL) {
throw new UnexpectedValueException("Property {$class}::\${$name} must be array or NULL, " . gettype($_this->{$name}) . " given.");
}
} elseif ($cb = Reflection\ClassType::from($_this)->getExtensionMethod($name)) {
// extension methods
array_unshift($args, $_this);
return $cb->invokeArgs($args);
} else {
throw new MemberAccessException("Call to undefined method {$class}::{$name}().");
}
}
public function handleSave(Form $form)
{
if ($form->hasSaveButton() && $form->isSubmitted() === $form->getSaveButton()) {
try {
$this->mapper->entityManager->getRepository(get_class($form->data))->save($form->data);
} catch (\Exception $e) {
$ok = true;
if (is_array($this->onCatchError) || $this->onCatchError instanceof \Traversable) {
foreach ($this->onCatchError as $handler) {
if (\Nette\Callback::create($handler)->invokeArgs(array($form, $e))) {
$ok = false;
break;
}
}
} elseif ($this->onCatchError !== NULL) {
$class = get_class($this);
throw new \Nette\UnexpectedValueException("Property {$class}::onCatchError must be array or NULL, " . gettype($this->onCatchError) . " given.");
}
if ($ok) {
throw $e;
}
}
}
}
public function handleSetParent($from = NULL, $to = NULL, $dropmode = NULL)
{
Callback::create($this->dropCallback)->invoke($from, $to, $dropmode);
}
/**
* __get() implementation.
*
* @param object
* @param string property name
*
* @return mixed property value
* @throws MemberAccessException if the property is not defined.
*/
public static function &get($_this, $name)
{
$class = get_class($_this);
$uname = ucfirst($name);
if (!isset(self::$methods[$class])) {
self::$methods[$class] = array_flip(get_class_methods($class));
// public (static and non-static) methods
}
if ($name === '') {
throw new MemberAccessException("Cannot read a class '{$class}' property without name.");
} elseif (isset(self::$methods[$class][$m = 'get' . $uname]) || isset(self::$methods[$class][$m = 'is' . $uname])) {
// property getter
$val = $_this->{$m}();
return $val;
} elseif (isset(self::$methods[$class][$name])) {
// public method as closure getter
$val = Callback::create($_this, $name);
return $val;
} else {
// strict class
$type = isset(self::$methods[$class]['set' . $uname]) ? 'a write-only' : 'an undeclared';
throw new MemberAccessException("Cannot read {$type} property {$class}::\${$name}.");
}
}
/**
* Calls method using autowiring.
* @param mixed class, object, function, callable
* @param array arguments
* @return mixed
*/
public function callMethod($function, array $args = array())
{
$callback = new Nette\Callback($function);
return $callback->invokeArgs(Helpers::autowireArguments($callback->toReflection(), $args, $this));
}
/**
* Formats PHP code for class instantiating, function calling or property setting in PHP.
* @return string
* @internal
*/
public function formatStatement(Statement $statement, $self = NULL)
{
$entity = $this->normalizeEntity($statement->entity);
$arguments = $statement->arguments;
if (is_string($entity) && Strings::contains($entity, '?')) {
// PHP literal
return $this->formatPhp($entity, $arguments, $self);
} elseif ($service = $this->getServiceName($entity)) {
// factory calling or service retrieving
if ($this->definitions[$service]->shared) {
if ($arguments) {
throw new ServiceCreationException("Unable to call service '{$entity}'.");
}
return $this->formatPhp('$this->getService(?)', array($service));
}
$params = array();
foreach ($this->definitions[$service]->parameters as $k => $v) {
$params[] = preg_replace('#\\w+$#', '\\$$0', is_int($k) ? $v : $k) . (is_int($k) ? '' : ' = ' . PhpHelpers::dump($v));
}
$rm = new Nette\Reflection\GlobalFunction(create_function(implode(', ', $params), ''));
$arguments = Helpers::autowireArguments($rm, $arguments, $this);
return $this->formatPhp('$this->?(?*)', array(Container::getMethodName($service, FALSE), $arguments), $self);
} elseif ($entity === 'not') {
// operator
return $this->formatPhp('!?', array($arguments[0]));
} elseif (is_string($entity)) {
// class name
if ($constructor = Nette\Reflection\ClassType::from($entity)->getConstructor()) {
$this->addDependency($constructor->getFileName());
$arguments = Helpers::autowireArguments($constructor, $arguments, $this);
} elseif ($arguments) {
throw new ServiceCreationException("Unable to pass arguments, class {$entity} has no constructor.");
}
return $this->formatPhp("new {$entity}" . ($arguments ? '(?*)' : ''), array($arguments), $self);
} elseif (!Validators::isList($entity) || count($entity) !== 2) {
throw new Nette\InvalidStateException("Expected class, method or property, " . PhpHelpers::dump($entity) . " given.");
} elseif ($entity[0] === '') {
// globalFunc
return $this->formatPhp("{$entity['1']}(?*)", array($arguments), $self);
} elseif (Strings::contains($entity[1], '$')) {
// property setter
Validators::assert($arguments, 'list:1', "setup arguments for '" . Nette\Callback::create($entity) . "'");
if ($this->getServiceName($entity[0], $self)) {
return $this->formatPhp('?->? = ?', array($entity[0], substr($entity[1], 1), $arguments[0]), $self);
} else {
return $this->formatPhp($entity[0] . '::$? = ?', array(substr($entity[1], 1), $arguments[0]), $self);
}
} elseif ($service = $this->getServiceName($entity[0], $self)) {
// service method
if ($this->definitions[$service]->class) {
$arguments = $this->autowireArguments($this->definitions[$service]->class, $entity[1], $arguments);
}
return $this->formatPhp('?->?(?*)', array($entity[0], $entity[1], $arguments), $self);
} else {
// static method
$arguments = $this->autowireArguments($entity[0], $entity[1], $arguments);
return $this->formatPhp("{$entity['0']}::{$entity['1']}(?*)", array($arguments), $self);
}
}
/**
* @return array
*/
protected static function exportRules($rules)
{
$payload = array();
foreach ($rules as $rule) {
if (!is_string($op = $rule->operation)) {
$op = new Nette\Callback($op);
if (!$op->isStatic()) {
continue;
}
}
if ($rule->type === Rule::VALIDATOR) {
$item = array('op' => ($rule->isNegative ? '~' : '') . $op, 'msg' => $rules->formatMessage($rule, FALSE));
} elseif ($rule->type === Rule::CONDITION) {
$item = array('op' => ($rule->isNegative ? '~' : '') . $op, 'rules' => self::exportRules($rule->subRules), 'control' => $rule->control->getHtmlName());
if ($rule->subRules->getToggles()) {
$item['toggle'] = $rule->subRules->getToggles();
}
}
if (is_array($rule->arg)) {
foreach ($rule->arg as $key => $value) {
$item['arg'][$key] = $value instanceof IControl ? (object) array('control' => $value->getHtmlName()) : $value;
}
} elseif ($rule->arg !== NULL) {
$item['arg'] = $rule->arg instanceof IControl ? (object) array('control' => $rule->arg->getHtmlName()) : $rule->arg;
}
$payload[] = $item;
}
return $payload;
}
/**
* Caches results of function/method calls.
* @param mixed
* @param array dependencies
* @return Closure
*/
public function wrap($function, array $dependencies = NULL)
{
$cache = $this;
return function () use($cache, $function, $dependencies) {
$key = array($function, func_get_args());
$data = $cache->load($key);
if ($data === NULL) {
$data = $cache->save($key, Nette\Callback::create($function)->invokeArgs($key[1]), $dependencies);
}
return $data;
};
}
/**
* @return RegistrationControl
*/
public function invoke($userType, $mode, $loginProviderMode, $roles, $emailSender, $emailFrom, $emailSubject, $emailText)
{
return Callback::create($this->factory)->invoke($userType, $mode, $loginProviderMode, $roles, $emailSender, $emailFrom, $emailSubject, $emailText);
}
/**
* {use class MacroSet}
*/
public function macroUse(MacroNode $node, PhpWriter $writer)
{
Nette\Callback::create($node->tokenizer->fetchWord(), 'install')->invoke($this->getCompiler())->initialize();
}
protected function createComponent($name)
{
return $this->factory->invoke($name, $this);
}
protected function createComponentNavbarForm()
{
$_this = $this;
$form = $this->navbarForms[$this->formName];
$entity = $form->getEntityFactory() ? Callback::create($form->getEntityFactory())->invoke() : $this->repository->createNew();
$form = $form->getFactory()->invoke($entity);
$form->onSuccess[] = $this->navbarFormSuccess;
$form->onError[] = $this->navbarFormError;
if ($this->mode == self::MODE_PLACE) {
$form->addSubmit('_cancel', 'Cancel')->setValidationScope(FALSE)->onClick[] = function () use($_this) {
$_this->redirect('this', array('formName' => NULL, 'mode' => NULL));
};
}
return $form;
}
/**
* @return \CmsModule\Content\Entities\ExtendedPageEntity
*/
public function getExtendedPage()
{
if (!$this->extendedPage) {
$this->extendedPage = Callback::create($this->extendedPageCallback)->invoke();
}
return $this->extendedPage;
}
/**
* @param $callback
* @return $this
* @throws \movi\InvalidArgumentException
*/
public function setRenderer($callback)
{
if (!is_callable($callback)) {
throw new InvalidArgumentException('Renderer is not callable');
}
$this->renderer = Callback::create($callback);
return $this;
}
/**
* Generates code.
* @return string
*/
private function compile(MacroNode $node, $def)
{
$node->tokenizer->reset();
$writer = Latte\PhpWriter::using($node, $this->compiler);
if (is_string($def)) {
return $writer->write($def);
} else {
return Nette\Callback::create($def)->invoke($node, $writer);
}
}