/** * Run the default json controller * * @param $parameters Parameters * @param $form array * @param $files array * @param $class_name string * @return string */ public function run(Parameters $parameters, $form, $files, $class_name) { $parameters = $parameters->getObjects(); // read all objects corresponding to class name if (!$parameters) { return json_encode(Dao::readAll(Names::setToClass($class_name, false), [Dao::sort()])); } // read object $first_parameter = reset($parameters); if (is_object($first_parameter)) { return json_encode($first_parameter); } // search objects for autocomplete combo pull-down list if (isset($parameters['term'])) { $element_class_name = Names::setToClass($class_name, false); $search = null; if (!empty($parameters['term'])) { $search = (new Search_Array_Builder())->buildMultiple(new Reflection_Class($element_class_name), $parameters['term'], '', '%'); } if (isset($parameters['filters']) && $parameters['filters']) { if (!(is_object($search) && $search->isAnd())) { $search = Dao\Func::andOp($search ? [$search] : []); } foreach ($parameters['filters'] as $filter_name => $filter_value) { $search->arguments[$filter_name] = $filter_value[0] == '!' ? Dao\Func::notEqual(substr($filter_value, 1)) : $filter_value; } if (count($search->arguments) == 1) { reset($search->arguments); $search = [key($search->arguments) => current($search->arguments)]; } } $objects = []; // first object only if (isset($parameters['first']) && $parameters['first']) { $objects = Dao::search($search, $element_class_name, [Dao::sort(), Dao::limit(1)]); $source_object = $objects ? reset($objects) : Builder::create($element_class_name); return json_encode(new Autocomplete_Entry(Dao::getObjectIdentifier($source_object), strval($source_object))); } else { $search_options = [Dao::sort()]; if (isset($parameters['limit'])) { $search_options[] = Dao::limit($parameters['limit']); } foreach (Dao::search($search, $element_class_name, $search_options) as $source_object) { $objects[] = new Autocomplete_Entry(Dao::getObjectIdentifier($source_object), strval($source_object)); } return json_encode($objects); } } elseif (isset($parameters['id'])) { $element_class_name = Names::setToClass($class_name); $source_object = Dao::read($parameters['id'], $element_class_name); return json_encode(new Autocomplete_Entry(Dao::getObjectIdentifier($source_object), strval($source_object))); } return ''; }
/** * Gets the class name associated to a store set name * * TODO HIGH used by Maintainer only : remove this call and prefer storage-class association cache * * @example 'my_addresses' will become 'A\Namespace\My\Address' * @param $store_name string * @return string Full class name with namespace */ public function classNameOf($store_name) { $class_name = Namespaces::fullClassName(Names::setToClass(str_replace(SP, '_', ucwords(str_replace('_', SP, $store_name))), false), false); if (strpos($class_name, BS) === false) { $class_name = explode('_', $class_name); foreach ($class_name as $key => $class_name_part) { $class_name[$key] = Names::setToClass($class_name_part, false); } $class_name = Namespaces::fullClassName(join('_', $class_name), false); } return $class_name; }
/** * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { $parameters->set(Parameter::CONTAINER, 'inside_tree'); $search = $parameters->getRawParameter('search'); if (empty($search)) { return parent::run($parameters, $form, $files); } $search = strtolower(str_replace([DOT, '*', '?'], [BS . DOT, '.*', '.?'], strSimplify($search, '.*? ' . BS))); $class_name = Names::setToClass($parameters->shift()); $properties = $this->searchProperties($class_name, $search); $top_property = new Property(); $top_property->class = $class_name; $objects = $parameters->getObjects(); array_unshift($objects, $top_property); $objects['class_name'] = $class_name; $objects['properties'] = $properties; $objects['display_full_path'] = true; return View::run($objects, $form, $files, Property::class, 'select'); }
/** * @param $property Reflection_Property * @return string[] Possibles properties names */ private function defaultMap(Reflection_Property $property) { $possibles = []; $foreign_class = $this->getForeignClass($property); foreach ($foreign_class->getProperties([T_EXTENDS, T_USE]) as $foreign_property) { $foreign_type = $foreign_property->getType(); if ($foreign_type->isClass() && $foreign_type->isMultiple() && is_a($property->getFinalClassName(), $foreign_type->getElementTypeAsString(), true) && $foreign_property->getAnnotation('link')->value == Link_Annotation::MAP && ($foreign_property->getDeclaringClassName() != $property->getDeclaringClassName() || $foreign_property->getName() != $property->getName())) { $possibles[$foreign_property->getName()] = $foreign_property; } } $possibles = Replaces_Annotations::removeReplacedProperties($possibles); if (count($possibles) != 1) { $this->value = Names::classToProperty(Names::setToClass($property->getDeclaringClass()->getAnnotation('set')->value)); } return array_keys($possibles); }
/** * Generates a link for to an object and feature, using parameters if needed * * @param $object object|string linked object or class name * @param $feature string linked feature name * @param $parameters string|string[]|object|object[] optional parameters list * @param $arguments string|string[] optional arguments list * @return string */ public function link($object, $feature = null, $parameters = null, $arguments = null) { // class name : not Built, not Set $class_names = is_string($object) ? $object : get_class($object); $class_name = Names::setToClass($class_names, false); $set_class = $class_name != $class_names; while (Builder::isBuilt($class_name)) { $class_name = get_parent_class($class_name); } if ($set_class) { $class_name = Names::classToSet($class_name); } // build uri $link = str_replace(BS, SL, is_object($object) && Dao::getObjectIdentifier($object) ? $class_name . SL . Dao::getObjectIdentifier($object) : $class_name); if (isset($feature)) { $link .= SL . $feature; } if (isset($parameters)) { if (!is_array($parameters)) { $parameters = [$parameters]; } foreach ($parameters as $key => $value) { if (!is_numeric($key)) { $link .= SL . $key; } if (is_object($value)) { $link .= SL . Names::classToUri(get_class($value)) . SL . Dao::getObjectIdentifier($value); } else { $link .= SL . $value; } } } // build arguments if (!empty($arguments)) { if (!is_array($arguments)) { $link .= '?' . urlencode($arguments); } else { $link .= '?'; $first = true; foreach ($arguments as $key => $value) { if ($first) { $first = false; } else { $link .= '&'; } $link .= $key . '=' . urlencode($value); } } } return SL . $link; }
/** * Parse URI text elements to transform them into parameters, feature name and controller name * * @example $uri = ['order', 148, 'form') will result on controller 'Order_Form' with parameter 'Order' = 148 * @param $uri string[] */ private function parseUri($uri) { // get main object = controller name $key = 0; $controller_element = ''; foreach ($uri as $key => $controller_element) { if (ctype_lower($controller_element[0]) || is_numeric($controller_element)) { break; } } if ($controller_element && ctype_upper($controller_element[0])) { $key++; } $this->controller_name = join(BS, array_slice($uri, 0, $key)); $uri = array_splice($uri, $key); // get main object (as first parameter) and feature name $this->feature_name = array_shift($uri); $this->parameters = new Parameters($this); if (is_numeric($this->feature_name)) { $this->parameters->set($this->controller_name, intval($this->feature_name)); $this->feature_name = array_shift($uri); if (!$this->feature_name) { $this->feature_name = Feature::F_OUTPUT; } } elseif ($this->controller_name && !$this->feature_name) { if (@class_exists($this->controller_name)) { $this->feature_name = Feature::F_ADD; } elseif (@class_exists(Names::setToClass($this->controller_name))) { $this->feature_name = Feature::F_LIST; } else { $this->feature_name = Feature::F_DEFAULT; } } // get main parameters $controller_elements = []; foreach ($uri as $uri_element) { if (ctype_upper($uri_element[0])) { $controller_elements[] = $uri_element; } else { if (is_numeric($uri_element)) { $this->parameters->set(join(BS, $controller_elements), intval($uri_element)); } else { if ($controller_elements) { $this->parameters->addValue(join(BS, $controller_elements)); } $this->parameters->addValue($uri_element); } $controller_elements = []; } } if ($controller_elements) { $this->parameters->addValue(join(BS, $controller_elements)); } }
/** * Get element class name of a given set class name (namespace needed) * * @param $class_name string * @return string */ public static function elementClassNameOf($class_name) { if (@is_a($class_name, __CLASS__, true)) { $class_name = (new $class_name())->element_class_name; } elseif (!@class_exists($class_name)) { $class_name = Names::setToClass($class_name, false); } return $class_name; }