/** * Handle the command. */ public function handle() { /* * Set the default buttons handler based * on the builder class. Defaulting to * no handler. */ if (!$this->builder->getButtons()) { $buttons = str_replace('TreeBuilder', 'TreeButtons', get_class($this->builder)); if (class_exists($buttons)) { $this->builder->setButtons($buttons . '@handle'); } } /* * Set the default segments handler based * on the builder class. Defaulting to * no handler. */ if (!$this->builder->getSegments()) { $segments = str_replace('TreeBuilder', 'TreeSegments', get_class($this->builder)); if (class_exists($segments)) { $this->builder->setSegments($segments . '@handle'); } } }
/** * Handle the command. */ public function handle() { $tree = $this->builder->getTree(); $model = $this->builder->getModel(); /** * If the model is already instantiated * then use it as is. */ if (is_object($model)) { $tree->setModel($model); return; } /** * If no model is set, try guessing the * model based on best practices. */ if (!$model) { $parts = explode('\\', str_replace('TreeBuilder', 'Model', get_class($this->builder))); unset($parts[count($parts) - 2]); $model = implode('\\', $parts); $this->builder->setModel($model); } /** * If the model is not set then skip it. */ if (!class_exists($model)) { return; } /** * Set the model on the tree! */ $tree->setModel(app($model)); }
/** * Handle the command. */ public function handle() { $tree = $this->builder->getTree(); $model = $tree->getModel(); /** * If a repository is set * then we don't have * anything to do. */ if ($this->builder->getTreeRepository()) { return; } $repository = $tree->getOption('repository'); /** * If there is no repository * then skip this step. */ if (!$repository) { return; } /** * Set the repository on the form! */ $tree->setRepository(app()->make($repository, compact('model', 'tree'))); }
/** * Handle the command. * * @param ResponseFactory $response */ public function handle(ResponseFactory $response) { $tree = $this->builder->getTree(); $options = $tree->getOptions(); $data = $tree->getData(); $tree->setResponse($response->view($options->get('wrapper_view', 'streams::blank'), $data)); }
/** * Handle the command. */ public function handle() { $this->builder->fire('saving', ['builder' => $this->builder]); $repository = $this->builder->getTreeRepository(); $repository->save($this->builder); $this->builder->fire('saved', ['builder' => $this->builder]); }
/** * Handle the command. */ public function handle() { $tree = $this->builder->getTree(); $options = $tree->getOptions(); $data = $tree->getData(); $content = view($options->get('tree_view', 'streams::tree/tree'), $data)->render(); $tree->setContent($content); $tree->addData('content', $content); }
/** * Normalize button input. * * @param TreeBuilder $builder */ public function normalize(TreeBuilder $builder) { $buttons = $builder->getButtons(); foreach ($buttons as $key => &$button) { /* * If the button is a string then use * it as the button parameter. */ if (is_string($button)) { $button = ['button' => $button]; } /* * If the key is a string and the button * is an array without a button param then * move the key into the button as that param. */ if (!is_integer($key) && !isset($button['button'])) { $button['button'] = $key; } /* * Make sure some default parameters exist. */ $button['attributes'] = array_get($button, 'attributes', []); /* * Move the HREF if any to the attributes. */ if (isset($button['href'])) { array_set($button['attributes'], 'href', array_pull($button, 'href')); } /* * Move the target if any to the attributes. */ if (isset($button['target'])) { array_set($button['attributes'], 'target', array_pull($button, 'target')); } /* * Move all data-* keys * to attributes. */ foreach ($button as $attribute => $value) { if (str_is('data-*', $attribute)) { array_set($button, 'attributes.' . $attribute, array_pull($button, $attribute)); } } /* * Make sure the HREF is absolute. */ if (isset($button['attributes']['href']) && is_string($button['attributes']['href']) && !starts_with($button['attributes']['href'], 'http')) { $button['attributes']['href'] = url($button['attributes']['href']); } /* * Use small buttons for trees. */ $button['size'] = array_get($button, 'size', 'xs'); } $builder->setButtons($buttons); }
/** * Merge in registered properties. * * @param TreeBuilder $builder */ public function merge(TreeBuilder $builder) { $buttons = $builder->getButtons(); foreach ($buttons as &$parameters) { if ($button = $this->buttons->get(array_get($parameters, 'button'))) { $parameters = array_replace_recursive($button, $parameters); } } $builder->setButtons($buttons); }
/** * Handle the command. * * @param Resolver $resolver * @param Evaluator $evaluator */ public function handle(Resolver $resolver, Evaluator $evaluator) { $arguments = ['builder' => $this->builder]; $tree = $this->builder->getTree(); $options = $this->builder->getOptions(); $options = $resolver->resolve($options, $arguments); $options = $evaluator->evaluate($options, $arguments); foreach ($options as $key => $value) { $tree->setOption($key, $value); } }
/** * Handle the command. */ public function handle() { $tree = $this->builder->getTree(); /* * Set the default options handler based * on the builder class. Defaulting to * no handler. */ if (!$tree->getOption('options')) { $options = str_replace('TreeBuilder', 'TreeOptions', get_class($this->builder)); if (class_exists($options)) { app()->call($options . '@handle', compact('builder', 'tree')); } } /* * Set the default data handler based * on the builder class. Defaulting to * no handler. */ if (!$tree->getOption('data')) { $options = str_replace('TreeBuilder', 'TreeData', get_class($this->builder)); if (class_exists($options)) { $tree->setOption('data', $options . '@handle'); } } /* * Set a optional entries handler based * on the builder class. Defaulting to * no handler in which case we will use * the model and included repositories. */ if (!$tree->getOption('entries')) { $entries = str_replace('TreeBuilder', 'TreeEntries', get_class($this->builder)); if (class_exists($entries)) { $tree->setOption('entries', $entries . '@handle'); } } /* * Set the default options handler based * on the builder class. Defaulting to * no handler. */ if (!$tree->getOption('repository')) { $model = $tree->getModel(); if (!$tree->getOption('repository') && $model instanceof EntryModel) { $tree->setOption('repository', EntryTreeRepository::class); } if (!$tree->getOption('repository') && $model instanceof EloquentModel) { $tree->setOption('repository', EloquentTreeRepository::class); } } }
/** * Build the items. * * @param TreeBuilder $builder */ public function build(TreeBuilder $builder) { foreach ($builder->getTreeEntries() as $entry) { $segments = $this->segments->build($builder, $entry); $buttons = $this->buttons->build($builder, $entry); $buttons = $buttons->enabled(); $id = $entry->getId(); $parent = $entry->{$builder->getTreeOption('parent_segment', 'parent_id')}; $item = compact('builder', 'segments', 'buttons', 'entry', 'parent', 'id'); $item = $this->evaluator->evaluate($item, compact('builder', 'entry')); $builder->addTreeItem($this->factory->make($item)); } }
/** * Handle the command. * * @param Asset $asset * @throws \Exception */ public function handle(Asset $asset) { foreach ($this->builder->getAssets() as $collection => $assets) { if (!is_array($assets)) { $assets = [$assets]; } foreach ($assets as $file) { $filters = explode('|', $file); $file = array_shift($filters); $asset->add($collection, $file, $filters); } } }
/** * Handle the command. */ public function handle() { $tree = $this->builder->getTree(); $model = $this->builder->getModel(); if (is_string($model) && !class_exists($model)) { return; } if (is_string($model)) { $model = app($model); } if ($model instanceof EntryInterface) { $tree->setStream($model->getStream()); } }
/** * Authorize the tree. * * @param TreeBuilder $builder */ public function authorize(TreeBuilder $builder) { // Try the option first. $permission = $builder->getTreeOption('permission'); /* * If the option is not set then * try and automate the permission. */ if (!$permission && ($module = $this->modules->active()) && ($stream = $builder->getTreeStream())) { $permission = $module->getNamespace($stream->getSlug() . '.read'); } if (!$this->authorizer->authorize($permission)) { abort(403); } }
/** * Save the tree. * * @param TreeBuilder $builder * @param array $items * @param null $parent */ public function save(TreeBuilder $builder, array $items = [], $parent = null) { $model = $builder->getTreeModel(); $items = $items ?: $builder->getRequestValue('items'); foreach ($items as $index => $item) { /* @var EloquentModel $entry */ $entry = $model->find($item['id']); $entry->{$builder->getTreeOption('sort_column', 'sort_order')} = $index + 1; $entry->{$builder->getTreeOption('parent_column', 'parent_id')} = $parent; $entry->save(); if (isset($item['children'])) { $this->save($builder, $item['children'], $item['id']); } } }
/** * Normalize the segment input. * * @param TreeBuilder $builder */ public function normalize(TreeBuilder $builder) { $segments = $builder->getSegments(); foreach ($segments as $key => &$segment) { /** * If the key is non-numerical then * use it as the header and use the * segment as the segment if it's a class. */ if (!is_numeric($key) && !is_array($segment) && class_exists($segment)) { $segment = ['heading' => $key, 'segment' => $segment]; } /** * If the key is non-numerical then * use it as the header and use the * segment as the value. */ if (!is_numeric($key) && !is_array($segment) && !class_exists($segment)) { $segment = ['heading' => $key, 'value' => $segment]; } /** * If the segment is not already an * array then treat it as the value. */ if (!is_array($segment)) { $segment = ['value' => $segment]; } /** * Move all data-* keys * to attributes. */ foreach ($segment as $attribute => $value) { if (str_is('data-*', $attribute)) { array_set($segment, 'attributes.' . $attribute, array_pull($segment, $attribute)); } } /** * If no value wrap is set * then use a default. */ array_set($segment, 'wrapper', array_get($segment, 'wrapper', '{value}')); /** * If there is no value then use NULL */ array_set($segment, 'value', array_get($segment, 'value', null)); } $builder->setSegments($segments); }
/** * Build the buttons. * * @param TreeBuilder $builder * @param $entry * @return ButtonCollection */ public function build(TreeBuilder $builder, $entry) { $tree = $builder->getTree(); $buttons = new ButtonCollection(); $this->input->read($builder, $entry); foreach ($builder->getButtons() as $button) { if (!array_get($button, 'enabled', true)) { continue; } $button = $this->evaluator->evaluate($button, compact('entry', 'tree')); $button = $this->parser->parse($button, $entry); $button = $this->factory->make($button); $buttons->push($button); } return $buttons; }
/** * Handle the command. * * @param Container $container * @param ViewTemplate $template * @param BreadcrumbCollection $breadcrumbs */ public function handle(Container $container, ViewTemplate $template, BreadcrumbCollection $breadcrumbs) { $tree = $this->builder->getTree(); $tree->addData('tree', $tree); if ($handler = $tree->getOption('data')) { $container->call($handler, compact('tree')); } if ($layout = $tree->getOption('layout_view')) { $template->put('layout', $layout); } if ($title = $tree->getOption('title')) { $template->put('title', $title); } if ($breadcrumb = $tree->getOption('breadcrumb')) { $breadcrumbs->put($breadcrumb, '#'); } }
/** * Guess the HREF for a button. * * @param TreeBuilder $builder */ public function guess(TreeBuilder $builder) { $buttons = $builder->getButtons(); // Nothing to do if empty. if (!($section = $this->sections->active())) { return; } foreach ($buttons as &$button) { // If we already have an HREF then skip it. if (isset($button['attributes']['href'])) { continue; } // Determine the HREF based on the button type. if ($type = array_get($button, 'button')) { $button['attributes']['href'] = $section->getHref($type . '/{entry.id}'); } } $builder->setButtons($buttons); }
/** * Build the segments. * * @param TreeBuilder $builder * @param $entry * @return SegmentCollection */ public function build(TreeBuilder $builder, $entry) { $tree = $builder->getTree(); $segments = new SegmentCollection(); if (!$builder->getSegments()) { $builder->setSegments(['entry.edit_link']); } $this->input->read($builder, $entry); foreach ($builder->getSegments() as $segment) { array_set($segment, 'entry', $entry); $segment = $this->evaluator->evaluate($segment, compact('entry', 'tree')); if (array_get($segment, 'enabled', null) === false) { continue; } $segment['value'] = $this->value->make($tree, $segment, $entry); $segments->push($this->factory->make($segment)); } return $segments; }
/** * Handle the command. */ public function handle() { $model = $this->builder->getModel(); /* * If the builder has an entries handler * then call it through the container and * let it load the entries itself. */ if ($handler = $this->builder->getTreeOption('entries')) { app()->call($handler, ['builder' => $this->builder]); return; } $entries = $this->builder->getTreeEntries(); /* * If the entries have already been set on the * tree then return. Nothing to do here. * * If the model is not set then they need * to load the tree entries themselves. */ if (!$entries->isEmpty() || !$model) { return; } /* * Resolve the model out of the container. */ $repository = $this->builder->getTreeRepository(); /* * If the repository is an instance of * TreeRepositoryInterface use it. */ if ($repository instanceof TreeRepositoryInterface) { $this->builder->setTreeEntries($repository->get($this->builder)); } }
/** * Translate the tree segments. * * @param TreeBuilder $builder */ public function translate(TreeBuilder $builder) { $builder->setSegments($this->translator->translate($builder->getSegments())); }
/** * Return the item value. * * @param TreeBuilder $builder * @param $entry * @return View|mixed|null */ public function make(TreeBuilder $builder, $entry) { $value = $builder->getTreeOption('item_value', 'entry.title'); /* * If the entry is an instance of EntryInterface * then try getting the field value from the entry. */ if ($entry instanceof EntryInterface && $entry->getField($value)) { if ($entry->assignmentIsRelationship($value)) { $value = $entry->{camel_case($value)}->getTitle(); } else { $value = $entry->getFieldValue($value); } } /* * If the value matches a field with a relation * then parse the string using the eager loaded entry. */ if (preg_match("/^entry.([a-zA-Z\\_]+)/", $value, $match)) { $fieldSlug = camel_case($match[1]); if (method_exists($entry, $fieldSlug) && $entry->{$fieldSlug}() instanceof Relation) { $entry = $this->decorator->decorate($entry); $value = data_get(compact('entry'), str_replace("entry.{$match[1]}.", 'entry.' . camel_case($match[1]) . '.', $value)); } } /* * Decorate the entry object before * sending to decorate so that data_get() * can get into the presenter methods. */ $entry = $this->decorator->decorate($entry); /* * If the value matches a method in the presenter. */ if (preg_match("/^entry.([a-zA-Z\\_]+)/", $value, $match)) { if (method_exists($entry, camel_case($match[1]))) { $value = $entry->{camel_case($match[1])}(); } } /* * By default we can just pass the value through * the evaluator utility and be done with it. */ $value = $this->evaluator->evaluate($value, compact('builder', 'entry')); /* * Lastly, prepare the entry to be * parsed into the string. */ if ($entry instanceof Arrayable) { $entry = $entry->toArray(); } else { $entry = null; } /* * Parse the value with the entry. */ $value = $this->parser->render($builder->getTreeOption('item_wrapper', '{value}'), compact('value', 'entry')); /* * If the value looks like a language * key then try translating it. */ if (str_is('*.*.*::*', $value)) { $value = trans($value); } return $value; }
/** * Parse the segments. * * @param TreeBuilder $builder */ public function parse(TreeBuilder $builder) { $builder->setSegments($this->parser->parse($builder->getSegments())); }
/** * Set the tree entries. * * @param \Illuminate\Support\Collection $entries * @return $this */ public function setTreeEntries(\Illuminate\Support\Collection $entries) { if (!$this->getFieldType()) { $entries = $entries->sort(function ($a, $b) { return array_search($a->id, $this->getSelected()) - array_search($b->id, $this->getSelected()); }); } return parent::setTreeEntries($entries); }
/** * Resolve tree views. * * @param TreeBuilder $builder */ public function resolve(TreeBuilder $builder) { $this->resolver->resolve($builder->getButtons(), compact('builder')); }