/**
* Returns a new instance of an object, but sets all its properties values to empty
*
* The empty value depends on the type of the property, simple type get an empty value of the
* same type. Object, resource, callable properties get an empty value of null.
*
* @param $class_name string
* @return object
*/
public static function create($class_name)
{
$object = Builder::create($class_name);
foreach ((new Reflection_Class($class_name))->accessProperties() as $property) {
if (!$property->isStatic()) {
switch ($property->getType()->asString()) {
case Type::INTEGER:
case Type::FLOAT:
$value = 0;
break;
case Type::STRING:
$value = '';
break;
case Type::BOOLEAN:
$value = false;
break;
case Type::_ARRAY:
$value = [];
break;
default:
$value = null;
}
$property->setValue($object, $value);
}
}
return $object;
}
/**
* @return Body
*/
protected function buildBody()
{
$body = parent::buildBody();
$row = $this->buildRow(Builder::create($this->class_name));
$row->addClass('new');
$body->addRow($row);
return $body;
}
/**
* @param $parameters Parameters
* @param $form array
* @param $class_name string
* @return mixed[]
*/
protected function getViewParameters(Parameters $parameters, $form, $class_name)
{
$parameters = $parameters->getObjects();
$object = reset($parameters);
if (empty($object) || !is_object($object) || !is_a($object, $class_name, true)) {
$object = Builder::create($class_name);
$parameters = array_merge([$class_name => $object], $parameters);
}
return $parameters;
}
/**
* Returns a new instance of an object, but sets all its properties values to null
*
* @param $class_name string
* @return object
*/
public static function create($class_name)
{
$object = Builder::create($class_name);
foreach ((new Reflection_Class($class_name))->accessProperties() as $property) {
if (!$property->isStatic()) {
$property->setValue($object, null);
}
}
return $object;
}
/**
* 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 '';
}
/**
* @before SAF\Framework\Dao\Data_Link::write($this)
*/
public function setNumber()
{
if (isA($this, Has_Counter::class)) {
/** @var $counter Counter */
$counter = Dao::searchOne(['class_name' => get_class($this)], Counter::class);
if (!isset($counter)) {
$counter = Builder::create(Counter::class, [get_class($this)]);
}
$this->setCounter($counter->increment());
}
}
/**
* @param $serialized string
* @return void
*/
public function unserialize($serialized)
{
$this->files = [];
foreach (unserialize($serialized) as $file_name => $temporary_file_name) {
/** @var $file File */
$file = Builder::create(File::class);
$file->name = $file_name;
$file->temporary_file_name = $temporary_file_name;
$this->files[] = $file;
}
}
/**
* @param $temporary_file_name string
*/
public function __construct($temporary_file_name = null)
{
if (isset($temporary_file_name)) {
if (!isset($this->name)) {
$this->name = rLastParse($temporary_file_name, SL, 1, true);
}
$this->temporary_file_name = $temporary_file_name;
}
if (!isset($this->updated_on)) {
$this->updated_on = Builder::create(Date_Time::class);
}
}
/**
* @param $source Reflection_Source
*/
public function onCompileSource(Reflection_Source $source)
{
Dao::begin();
foreach ($source->getClasses() as $class) {
/** @var $log Compiler_Log */
$log = Builder::create(Compiler_Log::class);
$log->class_name = $class->getName();
$log->date_time = Date_Time::now();
Dao::write($log);
$this->log_flag = true;
}
Dao::commit();
}
/**
* Get the object of class $class_name from session
*
* @param $class_name string
* @param $create_default boolean Create a default object for the class name if does not exist
* @return object|null
*/
public function get($class_name, $create_default = false)
{
if (isset($this->current[$class_name])) {
$current = $this->current[$class_name];
if (is_array($current)) {
$current = $current[1];
$this->current[$class_name] = $current = is_numeric($current) ? Dao::read($current, $class_name) : unserialize($current);
}
return $current;
} elseif ($create_default) {
return $this->current[$class_name] = Builder::create($class_name);
} else {
return null;
}
}
/**
* Returns a new instance of a search-formatted object of given class
*
* This creates an object with unset properties, as only set properties are used for searches.
* Private or protected properties can't be unset : they are kept with a null value.
*
* @param $class_name string
* @return object
*/
public static function create($class_name)
{
$object = Builder::create($class_name);
foreach ((new Reflection_Class(get_class($object)))->accessProperties() as $property) {
if (!$property->isStatic()) {
if ($property->isPublic()) {
$name = $property->name;
if (!isset($object->{$name}) || $object->{$name} !== $object) {
unset($object->{$name});
}
} else {
$property->setValue($object, null);
}
}
}
return $object;
}
/**
* @param $form array
* @param $name_element array
* @param $tmp_name_element array
* @return array
*/
private function appendToFormRecurse($form, $name_element, $tmp_name_element)
{
foreach ($name_element as $key => $name_sub_element) {
if (is_array($name_sub_element)) {
if (!isset($form[$key])) {
$form[$key] = [];
}
$form[$key] = $this->appendToFormRecurse($form[$key], $name_sub_element, $tmp_name_element[$key]);
} else {
/** @var $file File */
$file = Builder::create(File::class);
$file->name = $name_sub_element;
$file->temporary_file_name = $tmp_name_element[$key];
$form[$key] = $file;
}
}
return $form;
}
/**
* Encodes the email into MIME format
*
* Returns the MIME Multipart string
* If the mail is plain text without attachment, the plain text is returned without any change
*
* @return string
*/
public function encode()
{
if ($this->email->attachments || strpos($this->email->content, '<body')) {
/** @var $mail Mail_mime */
$mail = Builder::create(Mail_mime::class);
$body = $this->parseImages($mail, $this->email->content);
$error_reporting = error_reporting();
error_reporting(E_ALL & ~E_WARNING);
$mail->setTXTBody(convert_html_to_text($this->email->content));
error_reporting($error_reporting);
$mail->setHTMLBody($body);
$this->addAttachments($mail);
$mime_params = ['text_encoding' => '8bit', 'text_charset' => 'UTF-8', 'html_charset' => 'UTF-8', 'head_charset' => 'UTF-8'];
$body = $mail->get($mime_params);
$this->email->headers = $mail->headers($this->email->getHeadersAsStrings());
return $body;
}
return $this->email->content;
}
/**
* @param $template_file string
* @param $parameters array
* @param $feature_name string
* @return string
*/
protected function executeTemplate($template_file, $parameters, $feature_name)
{
if (isset($parameters[Template::TEMPLATE])) {
unset($parameters[Template::TEMPLATE]);
}
if (isset($parameters[Template::TEMPLATE_CLASS])) {
$template_class = $parameters[Template::TEMPLATE_CLASS];
} elseif (isset($parameters[Template::TEMPLATE_NAMESPACE])) {
$template_class = $parameters[Template::TEMPLATE_NAMESPACE] . BS . 'Html_Template';
unset($parameters[Template::TEMPLATE_NAMESPACE]);
} else {
$template_class = Template::class;
}
/** @var $template Template */
$template = Builder::create($template_class, [reset($parameters), $template_file, $feature_name]);
$template->setParameters($parameters);
$current = Framework\View::current();
if ($current instanceof Engine && ($css = $current->getCss())) {
$template->setCss($css);
}
return $template->parse();
}
/**
* @param $properties_list Reflection_Property[] new indices will be 'property.sub_property'
* @param $property Reflection_Property
* @param $object object
* @param $property_name string
* @param $display_prefix string
* @param $blocks string[]
* @return Reflection_Property[] added properties list (empty if none applies) indices are
* 'property.sub_property'
* @todo probably things to clean up (was patched for 'all properties as values' without controls)
*/
private static function expandUsingPropertyInternal(&$properties_list, $property, $object, $property_name, $display_prefix = '', $blocks = [])
{
$expanded = [];
/** @var $integrated Integrated_Annotation */
$integrated = $property->getListAnnotation('integrated');
if ($integrated->value && !$property->isStatic()) {
if ($integrated->has('block')) {
$blocks[$property->path ?: $property->name] = $property->path ?: $property->name;
}
$integrated_simple = $integrated->has('simple');
$sub_properties_class = $property->getType()->asReflectionClass();
$expand_properties = $sub_properties_class->getProperties([T_EXTENDS, T_USE]);
$value = $property->getValue($object) ?: Builder::create($property->getType()->asString());
foreach ($expand_properties as $sub_property_name => $sub_property) {
if (!$sub_property->getListAnnotation('user')->has(User_Annotation::INVISIBLE)) {
$display = $display_prefix . ($display_prefix ? DOT : '') . $property->name . DOT . $sub_property_name;
$sub_prefix = $integrated_simple ? $display_prefix : $display;
if ($more_expanded = self::expandUsingPropertyInternal($properties_list, $sub_property, $value, $property_name . DOT . $sub_property_name, $sub_prefix, $blocks)) {
$expanded = array_merge($expanded, $more_expanded);
} else {
$sub_property = new Reflection_Property_Value($sub_property->class, $sub_property->name, $value, false, true);
$sub_property->final_class = $sub_properties_class->name;
$sub_property->display = $integrated_simple ? $integrated->has('alias') ? $sub_property->getAnnotation('alias')->value : $sub_property_name : $display;
/** @var $block_annotation List_Annotation */
$block_annotation = $sub_property->setAnnotationLocal('block');
foreach ($blocks as $block) {
$block_annotation->add($block);
}
$sub_property->path = $property_name . DOT . $sub_property_name;
$properties_list[$property_name . DOT . $sub_property_name] = $sub_property;
$expanded[$property_name . DOT . $sub_property_name] = $sub_property;
}
}
}
}
return $expanded;
}
/**
* @param $controller string
* @param $method_name string
* @param $uri Uri
* @param $post array
* @param $files array
* @return string
*/
private function executeController($controller, $method_name, $uri, $post, $files)
{
$controller = Builder::create($controller);
if ($controller instanceof Class_Controller) {
return call_user_func_array([$controller, $method_name], [$uri->parameters, $post, $files, $uri->feature_name, $uri->controller_name]);
} else {
return call_user_func_array([$controller, $method_name], [$uri->parameters, $post, $files, $uri->controller_name, $uri->feature_name]);
}
}
/**
* Loads a Data_List_Settings from the Settings set
*
* If no Data_List_Settings named $name is stored, a new one will be returned
*
* @param $class_name string
* @param $name string
* @return Custom_Settings
*/
public static function load($class_name, $name)
{
/** @var $setting Setting */
$setting = new Setting($class_name . DOT . static::customId() . DOT . $name);
$setting = Dao::searchOne($setting);
$custom_settings = isset($setting) ? $setting->value : Builder::create(get_called_class(), [$class_name]);
$custom_settings->setting = self::currentUserSetting($class_name);
$custom_settings->setting->value = $custom_settings;
return $custom_settings;
}
/**
* @param $row array
* @param $class Import_Class
* @param $class_properties_column integer[]|string[]
* @return object
*/
private function writeNewObject($row, Import_Class $class, $class_properties_column)
{
$object = Builder::create($class->class_name);
foreach (array_keys($class->identify_properties) as $property_name) {
$object->{$property_name} = $row[$class_properties_column[$property_name]];
}
foreach (array_keys($class->write_properties) as $property_name) {
$object->{$property_name} = $row[$class_properties_column[$property_name]];
}
if ($this->simulation) {
$this->simulateNew($class, $object);
}
Dao::write($object);
return $object;
}
/**
* Gets the main object from the parameters
*
* If no main object is set (eq first parameter is not an object), create it using class name.
* Beware : the created object will then automatically be added to the beginning
* of the parameters list.
*
* @param $class_name string|object
* @param $search_by_properties string[]
* @return object
*/
public function getMainObject($class_name = null, $search_by_properties = [])
{
if (is_object($class_name)) {
$default_object = $class_name;
$class_name = get_class($class_name);
}
reset($this->parameters);
$object = $this->getObject(key($this->parameters));
if (!$object || !is_object($object)) {
if ($search_by_properties) {
$object = $this->searchMainObject($class_name, $search_by_properties);
}
if ((!$object || !is_object($object)) && !$class_name) {
$class_name = $this->uri->controller_name;
}
}
if (!$object || !is_object($object) || isset($class_name) && !is_a($object, $class_name)) {
$object = isset($default_object) ? $default_object : (isset($class_name) && @class_exists($class_name) ? Builder::create($class_name) : Set::instantiate($class_name));
$this->parameters = array_merge([get_class($object) => $object], $this->parameters);
}
return $object;
}
/**
* @param $text string
* @return string
*/
public static function parse($text)
{
/** @var $textile Textile */
$textile = Builder::create(Textile::class);
return $textile->textileThis($text);
}
/**
* Gets a plugin object
* If no plugin of this class name exists, the class is instantiated and the plugin registered
*
* @param $class_name string
* @param $level string
* @param $register boolean
* @param $activate boolean
* @return Plugin
*/
public function get($class_name, $level = null, $register = false, $activate = false)
{
/** @var $plugin Plugin|boolean|string */
if (isset($this->plugins[$class_name])) {
$plugin = $this->plugins[$class_name];
} elseif (!($constructor = (new Reflection_Class($class_name))->getConstructor()) || !$constructor->getNumberOfParameters()) {
$plugin = Builder::create($class_name);
} else {
return null;
}
// unserialize plugin
if (!is_object($plugin)) {
static $protect = null;
if ($class_name == $protect) {
return null;
}
$protect = $class_name;
if (!isset($plugin)) {
trigger_error('Get plugin ' . $class_name . ' : it does not exist', E_USER_ERROR);
}
$serialized = $plugin;
// configuration
if (is_array($serialized)) {
$plugin = Builder::create($class_name, [$serialized]);
/** @noinspection PhpUndefinedFieldInspection */
$plugin->plugin_configuration = $serialized;
} elseif (is_string($serialized)) {
if (is_a($class_name, Serializable::class, true)) {
$plugin = unserialize($serialized);
} else {
$configuration = unserialize($serialized);
$plugin = Builder::create($class_name, [$configuration]);
/** @noinspection PhpUndefinedFieldInspection */
$plugin->plugin_configuration = $configuration;
}
} else {
$plugin = Builder::create($class_name);
}
// store plugin object into manager
$this->plugins[$class_name] = $plugin;
if (isset($level)) {
$this->plugins_tree[$level][$class_name] = $plugin;
} else {
foreach ($this->plugins_tree as $level => $plugins) {
if (isset($plugins[$class_name])) {
$this->plugins_tree[$level][$class_name] = $plugin;
break;
}
}
}
$protect = null;
$activate = true;
}
// register plugin
if ($register && $plugin instanceof Registerable) {
$weaver = isset($this->plugins[Weaver::class]) ? $this->plugins[Weaver::class] : null;
/** @var $plugin Registerable */
$plugin->register(new Register(isset($plugin->plugin_configuration) ? $plugin->plugin_configuration : null, $weaver));
$activate = true;
}
// activate plugin
if ($activate && $plugin instanceof Activable) {
if (isset($this->activated[$class_name])) {
trigger_error('Plugin ' . $class_name . ' just registered and already activated', E_USER_WARNING);
} else {
/** @var $plugin Activable */
$plugin->activate();
$this->activated[$class_name] = $plugin;
}
}
return $plugin;
}
/**
* @param $result mixed[]
* @param $first boolean
* @return array
*/
private function resultToRow($result, $first)
{
$row = [];
for ($i = 0; $i < $this->column_count; $i++) {
$j = $this->i_to_j[$i];
if (!isset($this->classes[$j])) {
$row[$this->columns[$j]] = $result[$i];
} else {
if (!isset($row[$this->columns[$j]])) {
// TODO LOW try to get the object from object map to avoid multiple instances
$row[$this->columns[$j]] = Builder::create($this->classes[$j]);
if ($first && !isset($this->reflection_classes[$this->classes[$j]])) {
$class = new Reflection_Class($this->classes[$j]);
$class->accessProperties();
$this->reflection_classes[$this->classes[$j]] = $class;
}
}
$property_name = $this->column_names[$i];
if ($property_name === 'id') {
$this->link->setObjectIdentifier($row[$this->columns[$j]], $result[$i]);
} else {
$row[$this->columns[$j]]->{$property_name} = $result[$i];
}
}
}
return $row;
}
/**
* @param $property_name string
* @param $format_value boolean
* @return mixed
*/
protected function parseSingleValue($property_name, $format_value = true)
{
$source_object = $object = reset($this->objects);
if (!strlen($property_name)) {
$object = $this->parseParent();
} elseif (is_numeric($property_name) && is_string($object)) {
$object = substr($object, $property_name, 1);
} elseif ($property_name === '#') {
$object = reset($this->var_names);
} elseif (strpos($property_name, '?')) {
$object = $this->parseConditional($property_name);
} elseif ($property_name[0] == Q && substr($property_name, -1) == Q || $property_name[0] == DQ && substr($property_name, -1) == DQ) {
$object = $this->parseConstant($property_name);
} elseif (isset($this->parse_class_name)) {
if ($property_name === 'class') {
$object = $this->parse_class_name;
} elseif (method_exists($this->parse_class_name, $property_name)) {
$object = $this->parseStaticMethod($this->parse_class_name, $property_name);
} elseif (property_exists($this->parse_class_name, $property_name)) {
$object = $this->parseStaticProperty($this->parse_class_name, $property_name);
} elseif (defined($this->parse_class_name . '::' . $property_name)) {
$object = constant($this->parse_class_name . '::' . $property_name);
} else {
$object = isA($this->parse_class_name, $this->parseClassName($property_name));
}
$this->parse_class_name = null;
} elseif ($property_name[0] >= 'A' && $property_name[0] <= 'Z') {
if (is_array($object) && (isset($object[$property_name]) || !@class_exists($property_name))) {
$object = $this->parseArrayElement($object, $property_name);
} elseif (strlen($property_name) > 1 && ($property_name[1] >= 'a' && $property_name[1] <= 'z' || strpos($property_name, BS) !== false)) {
$this->parse_class_name = $this->parseClassName($property_name);
} else {
$object = $this->parseConst($object, $property_name);
}
} elseif ($property_name[0] === AT) {
$object = $this->parseFunc(substr($property_name, 1));
} elseif ($i = strpos($property_name, '(')) {
if ((is_object($object) || ctype_upper($object[0])) && method_exists($object, substr($property_name, 0, $i))) {
$object = $this->parseMethod($object, $property_name);
} else {
$object = $this->callFunc(reset($this->objects), $property_name);
}
} elseif (is_array($object)) {
$object = $this->parseArrayElement($object, $property_name);
} elseif (!is_object($object) && !isset($this->parameters[$property_name])) {
$object = $this->parseString($object, $property_name);
} elseif ((is_object($object) || is_string($object) && !empty($object) && ctype_upper($object[0])) && method_exists($object, $property_name)) {
if ($property_name == 'value' && $object instanceof Reflection_Property && ($builder = $object->getAnnotation('widget')->value) && is_a($builder, Property::class, true)) {
$builder = Builder::create($builder, [$object, $this->parseMethod($object, $property_name), $this]);
/** @var $builder Property */
$object = $builder->buildHtml();
$format_value = false;
} else {
$object = $this->parseMethod($object, $property_name);
}
} elseif (isset($object->{$property_name})) {
$object = $this->parseProperty($object, $property_name);
} elseif (isset($this->parameters[$property_name])) {
$object = $this->parseParameter($object, $property_name);
} else {
$object = $this->parseProperty($object, $property_name);
}
if ($format_value && $source_object instanceof Reflection_Property && $property_name == 'value') {
$object = (new Reflection_Property_View($source_object))->formatValue($object);
}
return $object;
}
/**
* @param $serialized string
*/
public function unserialize($serialized)
{
$this->compilers = [];
foreach (unserialize($serialized) as $wave_number => $compilers) {
foreach ($compilers as $class_name) {
$this->compilers[$wave_number][] = Session::current()->plugins->has($class_name) ? Session::current()->plugins->get($class_name) : Builder::create($class_name);
}
}
}
/**
* @param $object object
* @param $property Reflection_Property
* @param $value string
* @param $null_if_empty boolean
* @return boolean true if property value is null
*/
private function buildProperty($object, Reflection_Property $property, $value, $null_if_empty)
{
$is_null = $null_if_empty;
// use widget
if ($this->from_form && ($builder = $property->getAnnotation('widget')->value) && is_a($builder, Property::class, true)) {
$builder = Builder::create($builder, [$property, $value]);
/** @var $builder Property */
$value2 = $builder->buildValue($object, $null_if_empty);
if ($value2 !== Property::DONT_BUILD_VALUE) {
$value = $value2;
$done = true;
}
}
if (!isset($done)) {
$type = $property->getType();
if ($type->isBasic()) {
// password
if ($encryption = $property->getAnnotation('password')->value) {
if ($value == Password::UNCHANGED) {
return true;
}
$value = (new Password($value, $encryption))->encrypted();
} else {
$value = $this->buildBasicValue($property, $value);
}
} elseif (is_array($value)) {
$link = $property->getAnnotation('link')->value;
// object
if ($link == Link_Annotation::OBJECT) {
$class_name = $property->getType()->asString();
$value = $this->buildObjectValue($class_name, $value, $null_if_empty);
} elseif ($link == Link_Annotation::COLLECTION) {
$class_name = $property->getType()->getElementTypeAsString();
$value = $this->buildCollection($class_name, $value, $null_if_empty, $object);
} else {
$value = $this->buildMap($value, $property->getType()->getElementTypeAsString(), $link);
}
} elseif (isset($value) && $property->getAnnotation('output')->value == 'string') {
/** @var $object_value Stringable */
$object_value = Builder::create($property->getType()->asString());
$object_value->fromString($value);
$value = $object_value;
}
}
// the property value is set only for official properties, if not default and not empty
$property_name = $property->name;
if ($value !== '' || !$property->getType()->isClass()) {
$object->{$property_name} = $value;
}
if (!$property->isValueEmptyOrDefault($value)) {
$is_null = false;
}
return $is_null;
}
/**
* @param $object object
* @return string HTML combo-box with filters
*/
protected function getCombo($object)
{
$class_name = get_class($object);
$edit = new Html_Builder_Type('replace_with', new Type($class_name), Builder::create($class_name));
return $edit->buildObject(null, $this->getFilters($object));
}
/**
* Parse a variable / function / include and returns its return value
*
* @param $property_name string can be an unique var or path.of.vars
* @param $format_value boolean
* @return string var value after reading value / executing specs (can be an object)
*/
protected function parseSingleValue($property_name, $format_value = true)
{
$property = $source_object = reset($this->objects);
if ($property instanceof Reflection_Property_Value && $property_name == 'value') {
if (($builder = $property->getAnnotation('widget')->value) && is_a($builder, Property::class, true)) {
$builder = Builder::create($builder, [$property, $property->value(), $this]);
/** @var $builder Property */
$builder->parameters[Feature::F_EDIT] = Feature::F_EDIT;
$value = $builder->buildHtml();
if ($builder instanceof Value_Widget) {
$value = (new Html_Builder_Property($property, $value))->setTemplate($this)->build();
}
} else {
$value = $property->getType()->isBoolean() ? $property->value() : parent::parseSingleValue($property_name, false);
if (($preprop = lLastParse($property->pathAsField(), '[', 1, false)) && (!isset($this->cache[self::PARSED_ID]) || !isset($this->cache[self::PARSED_ID][$this->getFormId()]) || !isset($this->cache[self::PARSED_ID][$this->getFormId()][$preprop]))) {
$this->cache[self::PARSED_ID][$this->getFormId()][$preprop] = true;
if ($property instanceof Reflection_Property_Value) {
$parent_object = $property->getObject();
$id = isset($parent_object) ? Dao::getObjectIdentifier($parent_object) : null;
$html_builder_type = new Html_Builder_Type('id', null, $id, $preprop);
$id_value = $html_builder_type->setTemplate($this)->build();
} else {
$id_value = '';
}
} else {
$id_value = '';
}
if ($property->getAnnotation('output')->value == 'string') {
$property->setAnnotationLocal('var')->value = 'string';
$value = isset($value) ? strval($value) : null;
$id_value = '';
}
$value = $id_value . (new Html_Builder_Property($property, $value))->setTemplate($this)->build();
}
} else {
$value = parent::parseSingleValue($property_name);
}
return $value;
}
/**
* @param $list_settings Data_List_Settings
* @return array search-compatible search array
*/
protected function applySearchParameters(Data_List_Settings $list_settings)
{
/** @var $search_parameters_parser Search_Parameters_Parser */
$search_parameters_parser = Builder::create(Search_Parameters_Parser::class, [$list_settings->class_name, $list_settings->search]);
$result = $search_parameters_parser->parse();
foreach ((new Reflection_Class($list_settings->class_name))->getAnnotations('on_data_list') as $execute) {
/** @var $execute Method_Annotation */
if ($execute->call($list_settings->class_name, [&$result]) === false) {
break;
}
}
return $result;
}
/**
* @param $view string
* @param $view_method_name string
* @param $parameters array
* @param $form array
* @param $files array
* @param $class_name string
* @param $feature_name string
* @return mixed
*/
private static function executeView($view, $view_method_name, $parameters, $form, $files, $class_name, $feature_name)
{
$object = reset($parameters);
$view_object = is_object($object) && isA($object, $view) ? reset($parameters) : Builder::create($view);
return $view_object->{$view_method_name}($parameters, $form, $files, $class_name, $feature_name);
}
/**
* Send an email using its account connection information
* or the default SMTP account configuration.
*
* @param $email Email
* @return boolean|string true if sent, error message if string
*/
public function send(Email $email)
{
// email send configuration
$params = $this->sendConfiguration($email);
// mime encode of email (for html, images and attachments)
/** @var $encoder Encoder */
$encoder = Builder::create(Encoder::class, [$email]);
$content = $encoder->encode();
// send email using PEAR Mail and Net_SMTP features
/** @var $mail Mail_smtp */
$mail = (new Mail())->factory('smtp', $params);
$error_reporting = error_reporting();
error_reporting(E_ALL & ~E_DEPRECATED & ~E_STRICT);
$send_result = $mail->send($email->getRecipientsAsStrings(), $email->getHeadersAsStrings(), $content);
error_reporting($error_reporting);
// user error when errors
if ($send_result instanceof PEAR_Error) {
return $email->send_message = strval($send_result);
}
$email->send_date = new Date_Time();
/** @noinspection PhpUndefinedFieldInspection */
$email->uidl = $mail->queued_as;
return true;
}
