PHP Container::call方法代码示例

 /**
  * Handle the filter.
  *
  * @param Builder              $query
  * @param FieldFilterInterface $filter
  * @param TableBuilder         $builder
  */
 public function handle(Builder $query, FieldFilterInterface $filter, TableBuilder $builder)
 {
     $stream = $filter->getStream();
     $fieldType = $stream->getFieldType($filter->getField());
     $fieldTypeQuery = $fieldType->getQuery();
     $this->container->call([$fieldTypeQuery, 'filter'], compact('query', 'filter', 'builder'));
 }

 /**
  * Evaluate a target entity with arguments.
  *
  * @param        $target
  * @param  array $arguments
  * @return mixed
  */
 public function evaluate($target, array $arguments = [])
 {
     /**
      * If the target is an instance of Closure then
      * call through the IoC it with the arguments.
      */
     if ($target instanceof \Closure) {
         return $this->container->call($target, $arguments);
     }
     /**
      * If the target is an array then evaluate
      * each of it's values.
      */
     if (is_array($target)) {
         foreach ($target as &$value) {
             $value = $this->evaluate($value, $arguments);
         }
     }
     /**
      * if the target is a string and is in a traversable
      * format then traverse the target using the arguments.
      */
     if (is_string($target) && !isset($arguments[$target]) && $this->isTraversable($target)) {
         $target = data_get($arguments, $target, $target);
     }
     return $target;
 }

 /**
  * Handle the view query.
  *
  * @param  TableBuilder  $builder
  * @param  Builder       $query
  * @param  ViewInterface $view
  * @return mixed
  * @throws \Exception
  */
 public function handle(TableBuilder $builder, Builder $query, ViewInterface $view)
 {
     $view->fire('querying', compact('builder', 'query'));
     if (!($handler = $view->getQuery())) {
         return;
     }
     // Self handling implies @handle
     if (is_string($handler) && !str_contains($handler, '@')) {
         $handler .= '@handle';
     }
     /*
      * If the handler is a callable string or Closure
      * then call it using the IoC container.
      */
     if (is_string($handler) || $handler instanceof \Closure) {
         $this->container->call($handler, compact('builder', 'query'));
     }
     /*
      * If the handle is an instance of ViewQueryInterface
      * simply call the handle method on it.
      */
     if ($handler instanceof ViewQueryInterface) {
         $handler->handle($builder, $query);
     }
 }

 /**
  * Handle the filter.
  *
  * @param Builder               $query
  * @param SearchFilterInterface $filter
  */
 public function handle(Builder $query, TableBuilder $builder, SearchFilterInterface $filter)
 {
     $stream = $filter->getStream();
     $model = $builder->getTableModel();
     /**
      * If the model is translatable then
      * join it's translations so they
      * are filterable too.
      *
      * @var EloquentQueryBuilder $query
      */
     if ($model->getTranslationModelName() && !$query->hasJoin($model->getTranslationTableName())) {
         $query->leftJoin($model->getTranslationTableName(), $model->getTableName() . '.id', '=', $model->getTranslationTableName() . '.' . $model->getRelationKey());
     }
     $query->where(function (Builder $query) use($filter, $stream) {
         foreach ($filter->getColumns() as $column) {
             $query->orWhere($column, 'LIKE', "%{$filter->getValue()}%");
         }
         foreach ($filter->getFields() as $field) {
             $filter->setField($field);
             $fieldType = $stream->getFieldType($field);
             $fieldTypeQuery = $fieldType->getQuery();
             $fieldTypeQuery->setConstraint('or');
             $this->container->call([$fieldTypeQuery, 'filter'], compact('query', 'filter', 'builder'));
         }
     });
 }

 /**
  * Filter value.
  *
  * @param  mixed   $value
  * @param  string  $filter
  *
  * @return mixed
  */
 protected function filterValue($value, $filter)
 {
     $resolver = $this->getFilterResolver($filter);
     if (method_exists($resolver[0], $resolver[1])) {
         return $this->app->call($resolver, ['value' => $value]);
     }
     return $value;
 }

 /**
  * Get the validator instance for the request.
  *
  * @return \Illuminate\Contracts\Validation\Validator
  */
 protected function getValidatorInstance()
 {
     $factory = $this->container->make(ValidationFactory::class);
     if (method_exists($this, 'validator')) {
         return $this->container->call([$this, 'validator'], compact('factory'));
     }
     return $factory->make($this->all(), $this->container->call([$this, 'rules']), $this->messages(), $this->attributes());
 }

 /**
  * Call and resolve depepndencies of a method if enabled.
  *
  * @author	Andrea Marco Sartori
  * @param	string	$method
  * @param	array	$parameters
  * @return	void
  */
 private function callIfExistsAndEnabled($method, array $parameters = [])
 {
     if (!$this->isEnabled()) {
         return;
     }
     if (method_exists($this, $method) && $this->{"{$method}IsEnabled"}()) {
         $this->container->call([$this, $method], $parameters);
     }
 }

 /**
  * Resolve the target.
  *
  * @param        $target
  * @param array  $arguments
  * @param array  $options
  * @return mixed
  */
 public function resolve($target, array $arguments = [], array $options = [])
 {
     $method = array_get($options, 'method', 'handle');
     if (is_string($target) && str_contains($target, '@') || is_callable($target)) {
         $target = $this->container->call($target, $arguments);
     } elseif (is_string($target) && class_exists($target) && class_implements($target, SelfHandling::class)) {
         $target = $this->container->call($target . '@' . $method, $arguments);
     }
     return $target;
 }

 /**
  * Register field's custom validators.
  *
  * @param Factory     $factory
  * @param FormBuilder $builder
  * @param FieldType   $fieldType
  */
 protected function registerValidators(Factory $factory, FormBuilder $builder, FieldType $fieldType)
 {
     foreach ($fieldType->getValidators() as $rule => $validator) {
         $handler = array_get($validator, 'handler');
         if (is_string($handler) && !str_contains($handler, '@')) {
             $handler .= '@handle';
         }
         $factory->extend($rule, function ($attribute, $value, $parameters, Validator $validator) use($handler, $builder) {
             return $this->container->call($handler, compact('attribute', 'value', 'parameters', 'builder', 'validator'));
         }, array_get($validator, 'message'));
     }
 }

 /**
  * Dispatch a command to its appropriate handler in the current process.
  *
  * @param  mixed  $command
  * @param  mixed  $handler
  * @return mixed
  */
 public function dispatchNow($command, $handler = null)
 {
     if ($handler || ($handler = $this->getCommandHandler($command))) {
         $callback = function ($command) use($handler) {
             return $handler->handle($command);
         };
     } else {
         $callback = function ($command) {
             return $this->container->call([$command, 'handle']);
         };
     }
     return $this->pipeline->send($command)->through($this->pipes)->then($callback);
 }

 /**
  * Make a route.
  *
  * @param                    $route
  * @param  array             $parameters
  * @return mixed|null|string
  */
 public function make($route, array $parameters = [])
 {
     if (method_exists($this, $method = $this->str->camel(str_replace('.', '_', $route)))) {
         $parameters['parameters'] = $parameters;
         return $this->container->call([$this, $method], $parameters);
     }
     if (!str_contains($route, '.') && ($stream = $this->entry->getStreamSlug())) {
         $route = "{$stream}.{$route}";
     }
     if (!str_contains($route, '::') && ($namespace = $this->locator->locate($this->entry))) {
         $route = "{$namespace}::{$route}";
     }
     return $this->url->make($route, $this->entry, $parameters);
 }

 /**
  * Run a macro.
  *
  * @param       $macro
  * @param Image $image
  * @return Image
  * @throws \Exception
  */
 public function run($macro, Image $image)
 {
     if (!($process = array_get($this->getMacros(), $macro))) {
         return $image;
     }
     if (is_array($process)) {
         foreach ($process as $method => $arguments) {
             $image->addAlteration($method, $arguments);
         }
     }
     if ($process instanceof \Closure) {
         $this->container->call($process, compact('image', 'macro'));
     }
     return $image;
 }

 /**
  * Create a new Grid instance.
  *
  * @param  \Illuminate\Contracts\Container\Container  $app
  */
 public function __construct(Container $app)
 {
     $this->app = $app;
     if (method_exists($this, 'initiate')) {
         $app->call([$this, 'initiate']);
     }
 }

 /**
  * Determine if the request passes the authorization check.
  *
  * @return bool
  */
 protected function passesAuthorization()
 {
     if (method_exists($this, 'authorize')) {
         return $this->container->call([$this, 'authorize']);
     }
     return false;
 }

 /**
  * Determine if the request passes the authorization check.
  *
  * @return bool
  */
 protected function passesAuthorization()
 {
     $enabled = false;
     if (method_exists($this, 'authorize')) {
         $enabled = $this->container->call([$this, 'authorize']);
     }
     return (bool) $enabled;
 }