/**
* Returns true if the property value into the object is validated into the object context
*
* @param $object object
* @return boolean
*/
public function validate($object)
{
$validated = true;
foreach ($this->property->getAnnotations() as $annotation_name => $annotation) {
if ($annotation instanceof Template\Property_Validator) {
/** @var $annotation Template\Property_Validator|Property_Validate_Annotation */
$validated_annotation = $annotation->validate($object);
if ($annotation->valid === true) {
$annotation->valid = Validate::INFORMATION;
}
if ($annotation->valid === false) {
$annotation->valid = Validate::ERROR;
}
if (is_null($annotation->valid)) {
return null;
} else {
if (!$validated_annotation) {
$this->report[] = $annotation;
}
$validated = $validated && $validated_annotation;
}
}
}
return $validated;
}
/**
* Property select controller, starting from a given root class
*
* @param $parameters Parameters
* - first : the root reference class name (ie a business object)
* - second : if set, the selected property path into the root reference class name
* @param $form array not used
* @param $files array not used
* @return mixed
*/
public function run(Parameters $parameters, $form, $files)
{
$class_name = Set::elementClassNameOf($parameters->shiftUnnamed());
$property_path = $parameters->shiftUnnamed();
if (empty($property_path)) {
$top_property = new Property();
$top_property->class = $class_name;
$properties = $this->getProperties(new Reflection_Class($class_name));
foreach ($properties as $property) {
$property->path = $property->name;
}
} else {
$top_property = new Reflection_Property($class_name, $property_path);
$properties = $this->getProperties(new Reflection_Class($top_property->getType()->getElementTypeAsString()), $top_property->final_class);
foreach ($properties as $property) {
$property->path = $property_path . DOT . $property->name;
}
if (!$parameters->getRawParameter(Parameter::CONTAINER)) {
$parameters->set(Parameter::CONTAINER, 'subtree');
}
}
$objects = $parameters->getObjects();
array_unshift($objects, $top_property);
$objects['properties'] = $properties;
$objects['class_name'] = $class_name;
$objects['display_full_path'] = false;
/**
* Objects for the view :
* first Property the property object (with selected property name, or not)
* 'properties' Reflection_Property[] all properties from the reference class
*/
return View::run($objects, $form, $files, Property::class, 'select');
}
/**
* @param $property Reflection_Property
* @param $value mixed
* @return Line[]
*/
private static function checkProperty(Reflection_Property $property, $value)
{
$report_lines = [];
if (is_null($value)) {
if (!$property->getAnnotation('null')) {
self::checkValue($report_lines, false, $property, new Null_Annotation(false, $property), $value);
}
} else {
foreach ($property->getAnnotations() as $annotation_name => $annotation) {
switch ($annotation_name) {
case 'min_length':
self::checkValue($report_lines, strlen($value) >= $annotation->value, $property, $annotation, $value);
break;
case 'max_length':
self::checkValue($report_lines, strlen($value) <= $annotation->value, $property, $annotation, $value);
break;
case 'min_value':
self::checkValue($report_lines, $value >= $annotation->value, $property, $annotation, $value);
break;
case 'max_value':
self::checkValue($report_lines, $value <= $annotation->value, $property, $annotation, $value);
break;
//case 'precision':
//case 'signed':
//case 'precision':
//case 'signed':
case 'var':
self::checkVar($report_lines, $property, $annotation, $value);
break;
}
}
}
return $report_lines;
}
/**
* @return string
*/
function table()
{
if (!isset($this->table)) {
$master_table = Dao::storeNameOf($this->property->class);
$foreign_table = Dao::storeNameOf($this->property->getType()->getElementTypeAsString());
$this->table = $master_table < $foreign_table ? $master_table . '_' . $foreign_table : $foreign_table . '_' . $master_table;
}
return $this->table;
}
/**
* @param $object object
* @param $foreign_object object
* @return string
*/
public function buildQuery($object, $foreign_object)
{
list($table, $field1, $field2, $id1, $id2) = Map::sqlElementsOf($object, $this->property, $foreign_object);
if ($this->property->getType()->getElementTypeAsString() == 'object') {
$class_field = substr($field2, 3) . '_class';
return 'INSERT INTO' . SP . BQ . $table . BQ . LF . 'SET ' . $field1 . ' = ' . $id1 . ', ' . $field2 . ' = ' . $id2 . ', ' . $class_field . ' = ' . Value::escape(get_class($foreign_object));
} else {
return 'INSERT INTO' . SP . BQ . $table . BQ . LF . 'SET ' . $field1 . ' = ' . $id1 . ', ' . $field2 . ' = ' . $id2;
}
}
/**
* @return string
*/
public function build()
{
$properties_name = [];
foreach ($this->property->getFinalClass()->getProperties([T_EXTENDS, T_USE]) as $property) {
if (!$property->isStatic()) {
$properties_name[$property->name] = $property->name;
}
}
return new Select($this->name, $properties_name, $this->property->name);
}
/**
* @param $property Reflection_Property
* @param $map object[]
*/
public function __construct(Reflection_Property $property, $map)
{
$this->property = $property;
$this->map = $map;
$this->class_name = $this->property->getType()->getElementTypeAsString();
$class = new Reflection_Class($this->class_name);
/** @var $representative Representative_Annotation */
$representative = $class->getListAnnotation('representative');
$this->properties = $representative->getProperties();
}
/**
* Get current environment name possible values
*
* @return mixed[]
*/
public function values()
{
$type = $this->property->getType();
if ($type->isClass()) {
return Dao::readAll($this->property->getType()->asString(), [Dao::sort()]);
} elseif ($values = $this->property->getListAnnotation('values')->values()) {
return array_combine($values, $values);
} else {
trigger_error("Unable to get {$this->property->name} environment values from type " . $type->asString(), E_USER_ERROR);
return null;
}
}
/**
* @return string[]
*/
protected function getProperties()
{
// gets all properties from collection element class
$class = new Reflection_Class($this->class_name);
$properties = $class->getProperties([T_EXTENDS, T_USE]);
// remove replaced properties
/** @var $properties Reflection_Property[] */
$properties = Replaces_Annotations::removeReplacedProperties($properties);
// remove linked class properties
$linked_class = $class->getAnnotation('link')->value;
if ($linked_class) {
foreach (array_keys((new Reflection_Class($linked_class))->getProperties([T_EXTENDS, T_USE])) as $property_name) {
unset($properties[$property_name]);
}
}
// remove composite property
$property_name = $this->property->getAnnotation('foreign')->value;
if (isset($properties[$property_name])) {
unset($properties[$property_name]);
}
// remove static and user-invisible properties
foreach ($properties as $property_name => $property) {
if ($property->isStatic() || $property->getListAnnotation('user')->has(User_Annotation::INVISIBLE)) {
unset($properties[$property_name]);
}
}
// returns properties
return $properties;
}
/**
* @param $object object
* @param $property Reflection_Property
* @return Standard_Cell
*/
protected function buildCell($object, Reflection_Property $property)
{
if (!isset($this->template)) {
$this->template = new Html_Template();
}
$value = $property->getValue($object);
$preprop = $this->preprop ? $this->preprop . '[' . $this->property->name . ']' : $this->property->name;
$builder = new Html_Builder_Property($property, $value, $preprop . '[]');
$input = $builder->setTemplate($this->template)->build();
if ($property->name == reset($this->properties)->name && !(new Reflection_Class($this->class_name))->getAnnotation('link')->value) {
$property_builder = new Html_Builder_Property();
$property_builder->setTemplate($this->template);
$id_input = new Input($preprop . '[id][' . $property_builder->template->nextCounter($preprop . '[id][]') . ']', isset($object->id) ? $object->id : null);
$id_input->setAttribute('type', 'hidden');
$input = $id_input . $input;
}
return new Standard_Cell($input);
}
/**
* Constructs a reflection property with value
*
* @example
* $pv = new Reflection_Property_Value('Class_Name', 'property_name', $object);
*
* @param $class_name string
* @param $property_name string
* @param $object object|mixed the object containing the value, or the value itself
* (in this case set $final_value tu true)
* @param $final_value boolean set to true if $object is a final value instead of the object
* containing the valued property
* @param $user boolean set to true if the property value will be used into an user
* display (ie an HTML template)
*/
public function __construct($class_name, $property_name, $object = null, $final_value = false, $user = false)
{
parent::__construct($class_name, $property_name);
$this->final_value = $final_value;
$this->path = $property_name;
if (!isset($this->object)) {
$this->object = $object;
} else {
echo 'DEAD CODE ? object is set for ' . $class_name . '::' . $property_name . BR;
}
$this->user = $user;
}
/**
* This cleanup method is called after loading and getting the current value
* in order to avoid crashes when some components of the setting disappeared in the meantime.
*
* @return integer number of changes made during cleanup : if 0, then cleanup was not necessary
*/
public function cleanup()
{
$changes_count = 0;
$class_name = $this->getClassName();
foreach ($this->classes as $key => $class) {
if ($class->property_path && !Reflection_Property::exists($class_name, join(DOT, $class->property_path))) {
unset($this->classes[$key]);
$changes_count++;
} else {
$changes_count += $class->cleanup();
}
}
return $changes_count;
}
/**
* @param $value mixed
* @return string
*/
public function formatValue($value)
{
$type = $this->property->getType();
if ($type->isDateTime()) {
return $this->formatDateTime($value);
} else {
switch ($type) {
case Type::BOOLEAN:
return $this->formatBoolean($value);
case Type::FLOAT:
return $this->formatFloat($value);
case Type::INTEGER:
return $this->formatInteger($value);
case Type::STRING:
return $this->formatString($value);
}
return $this->formatDefault($value);
}
}
/**
* @param $multiline boolean keep this value empty, it is not used because the @multiline
* annotation is automatically used
* @param $values string[] keep this value empty, it is not used because the @values annotation
* is automatically used
* @return Element
*/
protected function buildString($multiline = false, $values = null)
{
$values_captions = [];
$values = $this->property->getListAnnotation('values')->values();
foreach ($values as $value) {
$values_captions[$value] = Names::propertyToDisplay($value);
}
if ($values_captions && !in_array($this->value, $values_captions)) {
$values_captions[$this->value] = $this->value;
}
$element = parent::buildString($this->property->getAnnotation('multiline')->value, $values_captions);
if ($this->property->getAnnotation('mandatory')->value) {
$element->setAttribute('required', true);
}
if ($this->property->getAnnotation('password')->value) {
$element->setAttribute('type', 'password');
$element->setAttribute('value', strlen($this->value) ? Password::UNCHANGED : '');
}
return $element;
}
/**
* @param $class_name string
* @param $property_path string
* @param $use_reverse_translation boolean if true, will try reverse translation of property names
* @param $properties_alias string[] $property_path = string[string $property_alias]
* @return string
*/
public static function propertyPathOf($class_name, $property_path, $use_reverse_translation = false, $properties_alias = null)
{
if (isset($properties_alias) && isset($properties_alias[$property_path])) {
$property_path = $properties_alias[$property_path];
} elseif ($use_reverse_translation) {
$property_class_name = $class_name;
$property_names = [];
foreach (explode(DOT, $property_path) as $property_name) {
if ($asterisk = substr($property_name, -1) == '*') {
$property_name = substr($property_name, 0, -1);
}
$property = null;
$property_name = Names::displayToProperty($property_name);
try {
$property = new Reflection_Property($property_class_name, $property_name);
} catch (ReflectionException $e) {
$translated_property_name = Names::displayToProperty(Loc::rtr($property_name, $property_class_name));
try {
$property = new Reflection_Property($property_class_name, $translated_property_name);
$property_name = $translated_property_name;
} catch (ReflectionException $e) {
}
}
$property_names[] = $property_name . ($asterisk ? '*' : '');
if (!isset($property)) {
break;
}
$property_class_name = $property->getType()->getElementTypeAsString();
}
$property_path = join(DOT, $property_names);
}
return $property_path;
}
/**
* Cleanup outdated properties from the list setting
*
* @return integer number of changes made during cleanup : if 0, then cleanup was not necessary
*/
public function cleanup()
{
$changes_count = 0;
// properties path
foreach ($this->properties_path as $key => $property_path) {
if (!Reflection_Property::exists($this->class_name, $property_path)) {
unset($this->properties_path[$key]);
$changes_count++;
}
}
if ($changes_count) {
$this->properties_path = array_values($this->properties_path);
}
// search
foreach (array_keys($this->search) as $property_path) {
if (!Reflection_Property::exists($this->class_name, $property_path)) {
unset($this->search[$property_path]);
$changes_count++;
}
}
// sort
if ($this->sort) {
foreach ($this->sort->columns as $key => $property_path) {
if (!Reflection_Property::exists($this->class_name, $property_path)) {
unset($this->sort->columns[$key]);
$changes_count++;
}
}
}
return $changes_count;
}
/**
* @param $description string
* @param $class_name string
* @param $property_name string
* @param $annotation_name string
* @param $assumed_value mixed
*/
private function testAnnotation($description, $class_name, $property_name, $annotation_name, $assumed_value)
{
$property = new Reflection_Property($class_name, $property_name);
$annotation = $property->getAnnotation($annotation_name);
$this->assume($class_name . DOT . $property_name . AT . $annotation_name . SP . DQ . $assumed_value . DQ . SP . '(' . $description . ')', $annotation->value, $assumed_value);
}
/**
* @param $object object
* @param $property Reflection_Property
* @param $map object[]
*/
private function writeMap($object, Reflection_Property $property, $map)
{
// old map
$class = new Link_Class(get_class($object));
$composite_property_name = $class->getAnnotation('link')->value ? $class->getCompositeProperty()->name : null;
$old_object = Search_Object::create(Link_Class::linkedClassNameOf($object));
$this->setObjectIdentifier($old_object, $this->getObjectIdentifier($object, $composite_property_name));
$aop_getter_ignore = Getter::$ignore;
Getter::$ignore = false;
$old_map = $property->getValue($old_object);
Getter::$ignore = $aop_getter_ignore;
// map properties : write each of them
$insert_builder = new Map_Insert($property);
$id_set = [];
foreach ($map as $element) {
$id = $this->getObjectIdentifier($element) ?: $this->getObjectIdentifier($this->write($element));
if (!isset($old_map[$id])) {
$query = $insert_builder->buildQuery($object, $element);
$this->connection->query($query);
} else {
$id_set[$id] = true;
}
}
// remove old unused elements
$delete_builder = new Map_Delete($property);
foreach ($old_map as $old_element) {
$id = $this->getObjectIdentifier($old_element);
if (!isset($id_set[$id])) {
$query = $delete_builder->buildQuery($object, $old_element);
$this->connection->query($query);
}
}
}
/**
* @param $object object
* @param $property Reflection_Property
* @param $value mixed
* @param $null_if_empty boolean
* @return boolean
*/
private function buildSubObject($object, Reflection_Property $property, $value, $null_if_empty)
{
$is_null = $null_if_empty;
$property_name = $property->name;
$type = $property->getType();
if (!isset($this->builders[$property_name])) {
$this->builders[$property_name] = new Object_Builder_Array($type->getElementTypeAsString(), $this->from_form);
}
$builder = $this->builders[$property_name];
if ($type->isMultiple()) {
$is_null = $this->buildSubObjectMultiple($object, $property_name, $value, $null_if_empty, $builder);
} else {
$value = $builder->build($value, null, $null_if_empty);
if (isset($value)) {
$object->{$property_name} = $value;
$is_null = false;
}
}
return $is_null;
}
/**
* Test property @getter : setting annotation value
*/
public function testGetterAnnotationSet()
{
$this->method('@getter : setting annotation value');
$property = new Reflection_Property(self::class, 'property');
// @getter methodName
$this->assume('methodName', (new Getter_Annotation('testGetterAnnotation', $property))->value, __CLASS__ . '::testGetterAnnotation');
// @getter Local_Class_Name::methodName
$this->assume('Local_Class_Name::methodName', (new Getter_Annotation('User_Annotation::has', $property))->value, User_Annotation::class . '::has');
// @getter Distant\Class\Full\Path::methodName
$this->assume('Distant\\Class\\Full\\Path\\Class_Name::methodName', (new Getter_Annotation(Annoted::class . '::has', $property))->value, Annoted::class . '::has');
// use Distant\Class\Full\Path\Class_Name
// @getter Class_Name::methodName
$this->assume('use Class_Name::methodName', (new Getter_Annotation('Annoted::has', $property))->value, Annoted::class . '::has');
// default value for getter when there is a @link annotation
$this->assume('default value when @link', $property->getAnnotation('getter')->value, Getter::class . '::getCollection');
}
/**
* @param $class_name string a class name
* @param $property_name string a property name or a property path starting from the class
* @return boolean true if the property exists
*/
public static function exists($class_name, $property_name)
{
if (strpos($property_name, DOT) !== false) {
$properties_name = explode(DOT, $property_name);
foreach (array_slice($properties_name, 0, -1) as $property_name) {
if (!property_exists($class_name, $property_name)) {
return false;
}
$property = new Reflection_Property($class_name, $property_name);
$class_name = $property->getType()->getElementTypeAsString();
}
$property_name = end($properties_name);
}
return property_exists($class_name, $property_name);
}
/**
* Gets mysql expression for a property type
*
* @param $property Reflection_Property
* @return string
*/
private static function propertyTypeToMysql(Reflection_Property $property)
{
$property_type = $property->getType();
if ($property_type->isBasic() || $property->getAnnotation('store')->value == 'string') {
if ($property_type->hasSize()) {
/** @var integer $max_length */
$max_length = $property->getAnnotation('max_length')->value;
$max_value = $property->getAnnotation('max_value')->value;
$min_value = $property->getAnnotation('min_value')->value;
$precision = $property->getAnnotation('precision')->value;
$signed = $property->getAnnotation('signed')->value;
$signed_length = $max_length + ($signed ? 1 : 0);
if (!isset($max_length)) {
if ($property_type->isNumeric()) {
$max_length = 18;
$signed_length = 18;
} else {
$max_length = 255;
}
}
if ($property_type->isInteger()) {
if (!isset($signed) && $max_value < 0 || $min_value < 0) {
$signed = true;
}
return $max_length <= 3 && $min_value >= -128 && $max_value <= 127 && $signed ? 'tinyint(' . $signed_length . ')' : ($max_length <= 3 && $min_value >= 0 && $max_value <= 255 && !$signed ? 'tinyint(' . $max_length . ') unsigned' : ($max_length <= 5 && $min_value >= -32768 && $max_value <= 32767 ? 'smallint(' . $signed_length . ')' : ($max_length <= 5 && $min_value >= 0 && $max_value <= 65535 ? 'smallint(' . $max_length . ') unsigned' : ($max_length <= 7 && $min_value >= -8388608 && $max_value <= 8388607 ? 'mediumint(' . $signed_length . ')' : ($max_length <= 8 && $min_value >= 0 && $max_value <= 16777215 ? 'mediumint(' . $max_length . ') unsigned' : ($max_length <= 10 && $min_value >= -2147483648.0 && $max_value <= 2147483647 ? 'int(' . $signed_length . ')' : ($max_length <= 10 && $min_value >= 0 && $max_value <= 4294967295.0 ? 'int(' . $max_length . ') unsigned' : ($max_length <= 19 && $min_value >= -9.223372036854776E+18 && $max_value <= 9.223372036854776E+18 ? 'bigint(' . $signed_length . ')' : 'bigint(' . $max_length . ') unsigned'))))))));
} elseif ($property_type->isFloat()) {
return $precision ? 'decimal(' . $signed_length . ', ' . $precision . ')' : 'double';
} elseif ($property->getAnnotation('binary')->value) {
return $max_length <= 65535 ? 'blob' : ($max_length <= 16777215 ? 'mediumblob' : 'longblob');
} else {
return $max_length <= 3 ? 'char(' . $max_length . ')' : ($max_length <= 255 ? 'varchar(' . $max_length . ')' : ($max_length <= 65535 ? 'text' : ($max_length <= 16777215 ? 'mediumtext' : 'longtext'))) . ' CHARACTER SET utf8 COLLATE utf8_general_ci';
}
}
switch ($property_type->asString()) {
case Type::_ARRAY:
return null;
case Type::BOOLEAN:
return 'tinyint(1)';
case Type::_CALLABLE:
return null;
case Type::null:
case Type::NULL:
return null;
case Type::RESOURCE:
return null;
case DateTime::class:
case Date_Time::class:
return 'datetime';
default:
return 'char(255)';
}
} elseif ($property_type->asString() === Type::STRING_ARRAY) {
/** @var $values string[] */
$values = [];
foreach ($property->getListAnnotation('values')->values() as $key => $value) {
$values[$key] = str_replace(Q, Q . Q, $value);
}
return $values ? ($property->getAnnotation('set')->value ? 'set' : 'enum') . "('" . join("','", $values) . "')" : 'text';
} else {
return 'bigint(18) unsigned';
}
}
/**
* @param $property Reflection_Property
* @return array[]
*/
private function getPropertyBlocks(Reflection_Property $property)
{
$blocks = [];
if ($property->getListAnnotation('integrated')->has('block')) {
$blocks[$property->path] = $property->path;
}
foreach ($property->getListAnnotation('block')->values() as $block) {
$blocks[$block] = $block;
}
return $blocks;
}
/**
* Generic getter for an object
*
* @param $stored mixed actual value of the object, or identifier to an object, or null
* @param $class_name string the object class name
* @param $object object the parent object
* @param $property string|Reflection_Property the parent property
* @return object
*/
public static function getObject(&$stored, $class_name, $object = null, $property = null)
{
if (!(self::$ignore || is_object($stored))) {
if ($property instanceof Reflection_Property) {
$property_name = $property->name;
} elseif (is_string($property) && is_object($object)) {
$property_name = $property;
$property = new Reflection_Property(get_class($object), $property_name);
}
if (is_object($object) && isset($property_name)) {
$id_property_name = 'id_' . $property_name;
if (isset($object->{$id_property_name})) {
$stored = $object->{$id_property_name};
}
}
if (isset($stored)) {
if (isset($property) && $property->getAnnotation('store')->value == 'string') {
/** @var $stored_object Stringable */
$stored_object = Builder::create($property->getType()->asString());
$stored_object->fromString($stored);
$stored = $stored_object;
} else {
$stored = isset($property) && ($dao = $property->getAnnotation('dao')->value) ? Dao::get($dao)->read($stored, $class_name) : Dao::read($stored, $class_name);
}
}
}
return $stored;
}
/**
* @param $join Join
* @param $master_path string
* @param $master_property_name string
* @param $foreign_path string
* @return string the foreign class name
*/
private function addSimpleJoin(Join $join, $master_path, $master_property_name, $foreign_path)
{
$foreign_class_name = null;
$master_property = $this->getProperty($master_path, $master_property_name);
if ($master_property) {
$foreign_type = $master_property->getType();
if ($foreign_type->isMultiple() && $foreign_type->getElementTypeAsString() == 'string') {
// TODO : string[] can have multiple implementations, depending on database engine
// linked strings table, mysql set.. should find a way to make this common without
// knowing anything about the specific
$foreign_class_name = $foreign_type->asString();
} elseif (!$foreign_type->isBasic()) {
$join->mode = $master_property->getAnnotation('mandatory')->value ? Join::INNER : Join::LEFT;
// force LEFT if any of the properties in the master property path is not mandatory
if ($join->mode == Join::INNER && $master_path) {
$root_class = new Reflection_Class($this->classes['']);
$property_path = '';
foreach (explode(DOT, $master_path . DOT . $master_property_name) as $property_name) {
$property_path .= ($property_path ? DOT : '') . $property_name;
$property = $root_class->getProperty($property_path);
if (!$property || !$property->getAnnotation('mandatory')->value) {
$join->mode = Join::LEFT;
break;
}
}
}
if ($foreign_type->isMultiple()) {
$foreign_class_name = $foreign_type->getElementTypeAsString();
$foreign_property_name = $master_property->getAnnotation('foreign')->value;
if (property_exists($foreign_class_name, $foreign_property_name) && $master_property->getAnnotation('link')->value != Link_Annotation::MAP) {
$foreign_property = new Reflection_Property($foreign_class_name, $foreign_property_name);
$join->foreign_column = 'id_' . $foreign_property->getAnnotation('storage')->value;
$join->master_column = 'id';
} else {
$this->addLinkedJoin($join, $master_path, $foreign_path, $foreign_class_name, $master_property);
}
} else {
$foreign_class_name = $foreign_type->asString();
$join->master_column = 'id_' . $master_property->getAnnotation('storage')->value;
$join->foreign_column = 'id';
}
}
}
return $foreign_class_name;
}
/**
* Builds column name from a property
*
* If property data type is an object, the property name will be prefixed with 'id_'.
* Array properties will return null as no column should be associated to them.
*
* @param $property Reflection_Property
* @return string|null
*/
public static function buildColumnName(Reflection_Property $property)
{
$type = $property->getType();
return $type->isBasic() ? $property->getAnnotation('storage')->value : ($type->isMultiple() ? null : 'id_' . $property->getAnnotation('storage')->value);
}
/**
* Prepares path_classes if it is null
* Must be called after prepareColumns()
*
* @param $property_name string
*/
private function preparePathClass($property_name)
{
$property = new Reflection_Property($this->class_name, $property_name);
$class_name = $property->getType()->getElementTypeAsString();
$this->path_classes[$property_name] = $class_name;
}
/**
* @param $property Reflection_Property
* @return boolean
*/
public function hasRange(Reflection_Property $property)
{
$type_string = $property->getType()->asString();
return in_array($type_string, [Date_Time::class, Type::INTEGER, Type::STRING]);
}
/**
* Changes an array into an object
*
* You should set only public and non-static properties values
*
* @param $class_name string
* @param $array array
* @return object
*/
public static function fromArray($class_name, $array)
{
$object = self::create($class_name);
if (isset($array)) {
foreach ($array as $property_name => $value) {
if (is_array($value)) {
$property = new Reflection_Property($class_name, $property_name);
if ($property->getType()->isClass()) {
$property_class_name = $property->getType()->getElementTypeAsString();
if ($property->getType()->isMultiple()) {
foreach ($value as $key => $val) {
$value[$key] = self::fromArray($property_class_name, $val);
}
} else {
$value = self::fromArray($property_class_name, $value);
}
$property->setValue($object, $value);
}
}
$object->{$property_name} = $value;
}
}
return $object;
}
/**
* Builds import settings using a recursive array coming from an input form
*
* @param $worksheet array
* @return Import_Settings
*/
public static function buildForm($worksheet)
{
$main_class_name = null;
$settings = new Import_Settings();
if (isset($worksheet['name'])) {
$settings->name = $worksheet['name'];
}
if (isset($worksheet['classes'])) {
foreach ($worksheet['classes'] as $property_path => $class) {
if (ctype_upper($property_path[0])) {
// the first element is always the main class name
$class_name = $main_class_name = $property_path;
$settings->class_name = $class_name;
$property_path = '';
} else {
// property paths for next elements
$property_path = str_replace('>', DOT, $property_path);
$property = new Reflection_Property($main_class_name, $property_path);
$class_name = $property->getType()->getElementTypeAsString();
}
$settings->classes[$property_path] = self::buildFormClass($class_name, $property_path, $class);
}
}
return $settings;
}