/**
* Factory for fetching the ViewModel
*
* @param string ViewModel classname without View_ prefix or full classname
* @param string Method to execute
* @return ViewModel
*/
public static function forge($view, $method = 'view', $auto_filter = null)
{
// strip any extensions from the view name to determine the viewmodel to load
$viewmodel = \Inflector::words_to_upper(str_replace(array('/', DS), '_', strpos($view, '.') === false ? $view : substr($view, 0, -strlen(strrchr($view, '.')))));
// determine the viewmodel namespace from the current request context
$namespace = \Request::active() ? ucfirst(\Request::active()->module) : '';
// list of possible viewmodel classnames, start with the namespaced one
$classes = array($namespace . '\\View_' . $viewmodel);
// add the global version if needed
empty($namespace) or $classes[] = 'View_' . $viewmodel;
/**
* Add non View_ prefixed classnames to the list, for BC reasons
*
* @deprecated 1.6
*/
$classes[] = $namespace . '\\' . $viewmodel;
// and add the global version of that if needed
empty($namespace) or $classes[] = $viewmodel;
// check if we can find one
foreach ($classes as $class) {
if (class_exists($class)) {
return new $class($method, $auto_filter, $view);
}
}
throw new \OutOfBoundsException('ViewModel "' . reset($classes) . '" could not be found.');
}
public function action_index($related_model_key, $selected_id)
{
$post_input = Input::post();
$this->request_data = $post_input['request_data'];
$this->base_form_name = $post_input['form_name'];
$this->base_model_name = 'Model_' . \Inflector::words_to_upper(ltrim($this->base_form_name, '_'));
$this->related_model_key = $related_model_key;
$this->related_model_name = 'Model_' . \Inflector::words_to_upper(str_replace('_id', '', ltrim($this->related_model_key, '_')));
// Process conditions for what options to get
$find_conditions_array = $relations_array = $order_by_array = [];
if (array_key_exists('conditions', $this->request_data)) {
if (array_key_exists('where', $this->request_data['conditions'])) {
foreach ($this->request_data['conditions']['where'] as $key => $value) {
if (strpos('_value', $value) !== false) {
$value = $selected_id;
}
$find_conditions_array[$key] = $value;
}
}
}
// Get related models with above conditions
$model_object = new $this->related_model_name();
$this->related_model = $model_object->find('all', ['where' => $find_conditions_array, 'related' => $relations_array, 'order_by' => $order_by_array]);
// Work out here what colour it is and if it's selected
// @todo code the conditional stuff!
if (array_key_exists('selected', $this->request_data)) {
$selected_array = $this->request_data['selected'];
} else {
$selected_array = [];
}
$colour = '';
// Process the returned related models into options using the template (if specified),
// and setting highlighting/selected attributes where appropriate.
foreach ($this->related_model as $related_model) {
in_array($related_model->id, $selected_array) ? $selected = 'selected="selected"' : ($selected = '');
// Prepare the option's text from the specified template
$text_object = new \EBS\Form_Option_Text($related_model, $this->request_data['template']);
$text = $text_object->get_text();
// Generate the option html and concatenate it to the options string
$option_html = "<option value=\"{$related_model->id}\"{$selected}{$colour}>{$text}</option>";
$this->options_html .= $option_html;
}
// Prepare the updated view for the response object.
$updated_view = new \EBS\Response_View();
$updated_view->html = $this->options_html;
$updated_view->context = $post_input['response_target'];
$this->response->updated_views[] = $updated_view;
// Encode the response object as JSON and send it back to the UI!
return Response::forge(json_encode($this->response));
}
/**
* Generates a new request. The request is then set to be the active
* request. If this is the first request, then save that as the main
* request for the app.
*
* Usage:
*
* Request::forge('hello/world');
*
* @param string The URI of the request
* @param mixed Internal: whether to use the routes; external: driver type or array with settings (driver key must be set)
* @param string request method
* @return Request The new request object
*/
public static function forge($uri = null, $options = true, $method = null)
{
is_bool($options) and $options = array('route' => $options);
is_string($options) and $options = array('driver' => $options);
if (!empty($options['driver'])) {
$class = \Inflector::words_to_upper('Request_' . $options['driver']);
return $class::forge($uri, $options, $method);
}
$request = new static($uri, isset($options['route']) ? $options['route'] : true, $method);
if (static::$active) {
$request->parent = static::$active;
static::$active->children[] = $request;
}
return $request;
}
private function deal_relation($action)
{
foreach (array_keys($this->id_keys) as $key) {
// If the key doesn't contain the name of the parent model we're creating, it's the relations name
if (strpos($key, $this->item_name) === false) {
$relation_name = str_replace('_id', '', $key);
$relation_model_name = 'Model_' . \Inflector::words_to_upper($relation_name);
$relation_model = new $relation_model_name();
// E.g. note->person[] = person
$this->models_and_actions[0][0]->{$relation_name}[] = $relation_model::find($this->id_keys[$key]);
}
}
if ($action !== 'delete' && $relation_model !== null) {
}
}
/**
* Generates a new request. The request is then set to be the active
* request. If this is the first request, then save that as the main
* request for the app.
*
* Usage:
*
* Request::forge('hello/world');
*
* @param string The URI of the request
* @param mixed Internal: whether to use the routes; external: driver type or array with settings (driver key must be set)
* @param string request method
* @return Request The new request object
*/
public static function forge($uri = null, $options = true, $method = null)
{
is_bool($options) and $options = array('route' => $options);
is_string($options) and $options = array('driver' => $options);
if (!empty($options['driver'])) {
$class = \Inflector::words_to_upper('Request_' . $options['driver']);
return $class::forge($uri, $options, $method);
}
$request = new static($uri, isset($options['route']) ? $options['route'] : true, $method);
if (static::$active) {
$request->parent = static::$active;
static::$active->children[] = $request;
}
// fire any request created events
\Event::instance()->has_events('request_created') and \Event::instance()->trigger('request_created', '', 'none');
return $request;
}
/**
* Factory for fetching the Presenter
*
* @param string Presenter classname without View_ prefix or full classname
* @param string Method to execute
* @param bool Auto filter the view data
* @param string View to associate with this persenter
* @return Presenter
*/
public static function forge($presenter, $method = 'view', $auto_filter = null, $view = null)
{
// determine the presenter namespace from the current request context
$namespace = \Request::active() ? ucfirst(\Request::active()->module) : '';
// create the list of possible class prefixes
$prefixes = array(static::$ns_prefix, $namespace . '\\');
/**
* Add non prefixed classnames to the list as well, for BC reasons
*
* @deprecated 1.6
*/
if (!empty($namespace)) {
array_unshift($prefixes, $namespace . '\\' . static::$ns_prefix);
$prefixes[] = '';
}
// loading from a specific namespace?
if (strpos($presenter, '::') !== false) {
$split = explode('::', $presenter, 2);
if (isset($split[1])) {
array_unshift($prefixes, ucfirst($split[0]) . '\\' . static::$ns_prefix);
$presenter = $split[1];
}
}
// if no custom view is given, make it equal to the presenter name
is_null($view) and $view = $presenter;
// strip any extensions from the view name to determine the presenter to load
$presenter = \Inflector::words_to_upper(str_replace(array('/', DS), '_', strpos($presenter, '.') === false ? $presenter : substr($presenter, 0, -strlen(strrchr($presenter, '.')))));
// create the list of possible presenter classnames, start with the namespaced one
$classes = array();
foreach ($prefixes as $prefix) {
$classes[] = $prefix . $presenter;
}
// check if we can find one
foreach ($classes as $class) {
if (class_exists($class)) {
return new $class($method, $auto_filter, $view);
}
}
throw new \OutOfBoundsException('Presenter "' . reset($classes) . '" could not be found.');
}
/**
* Used in the 'behind the scenes' logic during a frontend request, this checks whether
* there is a controller associated with a particular template
*
* @param string $template Path to the template, relative to the root of the views directory
* @return boolean
*/
public static function hasController($template)
{
static::$path = strpos($template, '.') === false ? $template : substr($template, 0, -strlen(strrchr($template, '.')));
// determine the viewmodel namespace and classname
if (empty(static::$module)) {
static::$module = \Request::active() ? ucfirst(\Request::active()->module) : '';
}
// Strip the first part of the path off for module templates
if (!empty(static::$module) && strpos(static::$path, static::$module) === 0) {
static::$path = str_replace(static::$module . '/', '', static::$path);
}
$controller_class = ucfirst(static::$module) . '\\Controller_' . \Inflector::words_to_upper(ucfirst(str_replace(array('/', DS), '_', static::$path)));
return class_exists($controller_class);
}
protected static function parse_segments($segments, $namespace = '', $module = false)
{
$temp_segments = $segments;
foreach (array_reverse($segments, true) as $key => $segment) {
$class = $namespace . 'Controller_' . \Inflector::words_to_upper(implode('_', $temp_segments));
array_pop($temp_segments);
if (class_exists($class)) {
return array('controller' => $class, 'action' => isset($segments[$key + 1]) ? $segments[$key + 1] : null, 'method_params' => array_slice($segments, $key + 2));
}
}
// Fall back for default module controllers
if ($module) {
$class = $namespace . 'Controller_' . ucfirst($module);
if (class_exists($class)) {
return array('controller' => $class, 'action' => isset($segments[0]) ? $segments[0] : null, 'method_params' => array_slice($segments, 1));
}
}
return false;
}
/**
* Find the controller that matches the route requested
*
* @param Route $match the given Route object
* @return mixed the match array or false
*/
protected static function find_controller($match)
{
// First port of call: request for a module?
if (\Fuel::module_exists($match->segments[0])) {
// make the module known to the autoloader
\Fuel::add_module($match->segments[0]);
$segments = $match->segments;
// first check if the controller is in a directory.
$match->module = array_shift($segments);
$match->directory = count($segments) ? array_shift($segments) : null;
$match->controller = count($segments) ? array_shift($segments) : $match->module;
// does the module controller exist?
if (class_exists(Inflector::words_to_upper($match->module . '\\Controller_' . $match->directory . '_' . $match->controller))) {
$match->action = count($segments) ? array_shift($segments) : null;
$match->method_params = $segments;
return $match;
}
$segments = $match->segments;
// then check if it's a module controller
$match->module = array_shift($segments);
$match->directory = null;
$match->controller = count($segments) ? array_shift($segments) : $match->module;
// does the module controller exist?
if (class_exists(Inflector::words_to_upper($match->module . '\\Controller_' . $match->controller))) {
$match->action = count($segments) ? array_shift($segments) : null;
$match->method_params = $segments;
return $match;
}
$segments = $match->segments;
// do we have a module controller with the same name as the module?
if ($match->controller != $match->module) {
array_shift($segments);
$match->controller = $match->module;
if (class_exists(Inflector::words_to_upper($match->module . '\\Controller_' . $match->controller))) {
$match->action = count($segments) ? array_shift($segments) : null;
$match->method_params = $segments;
return $match;
}
}
}
$segments = $match->segments;
// It's not a module, first check if the controller is in a directory.
$match->directory = array_shift($segments);
$match->controller = count($segments) ? array_shift($segments) : $match->directory;
if (class_exists(\Inflector::words_to_upper('Controller_' . $match->directory . '_' . $match->controller))) {
$match->action = count($segments) ? array_shift($segments) : null;
$match->method_params = $segments;
return $match;
}
$segments = $match->segments;
// It's not in a directory, so check for app controllers
$match->directory = null;
$match->controller = count($segments) ? array_shift($segments) : $match->directory;
// We first want to check if the controller is in a directory.
if (class_exists(\Inflector::words_to_upper('Controller_' . $match->controller))) {
$match->action = count($segments) ? array_shift($segments) : null;
$match->method_params = $segments;
return $match;
}
// none of the above. I give up. We've found ziltch...
$match->action = null;
$match->controller = null;
return $match;
}
protected static function parse_segments($segments, $namespace = '', $module = false)
{
$temp_segments = $segments;
$prefix = static::get_prefix();
foreach (array_reverse($segments, true) as $key => $segment) {
// determine which classes to check. First, all underscores, or all namespaced
$classes = array($namespace . $prefix . \Inflector::words_to_upper(implode(substr($prefix, -1, 1), $temp_segments), substr($prefix, -1, 1)));
// if we're namespacing, check a hybrid version too
$classes[] = $namespace . $prefix . \Inflector::words_to_upper(implode('_', $temp_segments));
array_pop($temp_segments);
foreach ($classes as $class) {
if (static::check_class($class)) {
return array('controller' => $class, 'action' => isset($segments[$key + 1]) ? $segments[$key + 1] : null, 'method_params' => array_slice($segments, $key + 2));
}
}
}
// Fall back for default module controllers
if ($module) {
$class = $namespace . $prefix . ucfirst($module);
if (static::check_class($class)) {
return array('controller' => $class, 'action' => isset($segments[0]) ? $segments[0] : null, 'method_params' => array_slice($segments, 1));
}
}
return false;
}
/**
* Translates a driver name to a class name
*
* @param string $name Name of the driver (eg, 'facebook')
* @return string 'Ethanol\Auth_Driver_Facebook'
*/
public function translate_driver_name($name)
{
return 'Ethanol\\Auth_Driver_' . \Inflector::words_to_upper($name);
}
/**
* Generates a new request. The request is then set to be the active
* request. If this is the first request, then save that as the main
* request for the app.
*
* Usage:
*
* Request::forge('hello/world');
*
* @param string The URI of the request
* @param mixed Internal: whether to use the routes; external: driver type or array with settings (driver key must be set)
* @return Request The new request object
*/
public static function forge($uri = null, $options = true)
{
logger(\Fuel::L_INFO, 'Creating a new Request with URI = "' . $uri . '"', __METHOD__);
is_bool($options) and $options = array('route' => $options);
is_string($options) and $options = array('driver' => $options);
if (!empty($options['driver'])) {
$class = \Inflector::words_to_upper('Request_' . $options['driver']);
return $class::forge($uri, $options);
}
$request = new static($uri, isset($options['route']) ? $options['route'] : true);
if (static::$active) {
$request->parent = static::$active;
static::$active->children[] = $request;
}
return $request;
}
