Exemplo n.º 1
0
 /**
  * The $object argument will be the first argument before $arguments in case of a static call
  * If the value is a method for the current object, only $arguments will be sent
  *
  * @param $object    object|string the object will be the first. If string, this is a class name
  * @param $arguments array
  * @return mixed the value returned by the called method
  */
 public function call($object, $arguments = [])
 {
     if ($this->static || is_string($object)) {
         return call_user_func_array($this->value, array_merge([$object], $arguments));
     }
     return call_user_func_array([$object, rParse($this->value, '::')], $arguments);
 }
Exemplo n.º 2
0
 /**
  * Validates the property value within this object context
  *
  * @param $object object
  * @return boolean
  */
 public function validate($object)
 {
     $this->object = $object;
     if ($this->property instanceof Reflection_Property) {
         if ($this->value) {
             $value = $this->property->getValue($object);
             $this->valid = strlen(rParse($value, '.')) <= $this->value;
         } else {
             $this->valid = true;
         }
     } else {
         $this->valid = null;
     }
     return $this->valid;
 }
Exemplo n.º 3
0
 /**
  * Run method for a feature controller working for any class
  *
  * @param $parameters Parameters
  * @param $form       array
  * @param $files      array
  * @param $class_name string
  * @return mixed
  */
 public function run(Parameters $parameters, $form, $files, $class_name)
 {
     if (isset($form['login']) && isset($form['password'])) {
         $current = User::current();
         if ($current) {
             Authentication::disconnect(User::current());
         }
         $user = Authentication::login($form['login'], $form['password']);
         if (isset($user)) {
             Authentication::authenticate($user);
             return self::AUTH_OK . rParse(Session::sid(), '=');
         }
     }
     return self::AUTH_ERROR;
 }
Exemplo n.º 4
0
 /**
  * @param $property Reflection_Property
  * @param $value    mixed
  * @param $preprop  string
  */
 public function __construct(Reflection_Property $property = null, $value = null, $preprop = null)
 {
     if (isset($property)) {
         $name = $property->pathAsField();
         if (strpos($name, '[')) {
             $preprop2 = lLastParse($name, '[');
             $preprop = $preprop ? $preprop . '[' . lParse($preprop2, '[') . '[' . rParse($preprop2, '[') : $preprop2;
             $name = lParse(rLastParse($name, '['), ']');
         }
         parent::__construct($name, $property->getType(), $value, $preprop);
         $this->null = $property->getAnnotation('null')->value;
         $this->property = $property;
         $this->readonly = $property->getListAnnotation('user')->has(User_Annotation::READONLY);
     } else {
         parent::__construct(null, null, $value, $preprop);
     }
 }
Exemplo n.º 5
0
/**
 * Returns the middle part of the string, between $begin_sep and $end_sep
 *
 * If separators are arrays, it will search the first separator, then the next one, etc.
 *
 * @example echo mParse('He eats, drinks and then sleep', [', ', SP], ' then ')
 *          Will result in 'and'
 *          It looks what is after ', ' and then what is after the next space
 *          The returned value stops before ' then '
 * @param $str       string
 * @param $begin_sep string|string[]
 * @param $end_sep   string|string[]
 * @param $cnt       integer
 * @return string
 */
function mParse($str, $begin_sep, $end_sep, $cnt = 1)
{
    // if $begin_sep is an array, rParse each $begin_sep element
    if (is_array($begin_sep)) {
        $sep = array_pop($begin_sep);
        foreach ($begin_sep as $beg) {
            $str = rParse($str, $beg, $cnt);
            $cnt = 1;
        }
        $begin_sep = $sep;
    }
    // if $end_sep is an array, lParse each $end_sep element, starting from the last one
    if (is_array($end_sep)) {
        $end_sep = array_reverse($end_sep);
        $sep = array_pop($end_sep);
        foreach ($end_sep as $end) {
            $str = lParse($str, $end);
        }
        $end_sep = $sep;
    }
    return lParse(rParse($str, $begin_sep, $cnt), $end_sep);
}
Exemplo n.º 6
0
 /**
  * @param $builder       Object_Builder_Array
  * @param $null_if_empty boolean
  * @param $object        object
  * @param $property_name string
  * @param $value         mixed
  * @return boolean
  */
 private function buildSubObjectMultiple($object, $property_name, $value, $null_if_empty, Object_Builder_Array $builder)
 {
     $is_null = $null_if_empty;
     if (is_array($value)) {
         // keys are numeric : multiple values case
         foreach ($value as $key => $element) {
             if (is_numeric($number = lParse($key, DOT, 1, false))) {
                 $values[$number][rParse($key, DOT)] = $element;
             } else {
                 unset($values);
                 break;
             }
         }
         // single value case
         if (!isset($values)) {
             $values = [$value];
         }
         // build values
         foreach ($values as $element) {
             $element = $builder->build($element, null, $null_if_empty);
             if (isset($element)) {
                 // call property getter if exist (do not remove this !)
                 $object->{$property_name};
                 array_push($object->{$property_name}, $element);
                 $is_null = false;
             }
         }
     }
     return $is_null;
 }
Exemplo n.º 7
0
 /**
  * @param $parameters Parameters
  * @param $form       array
  * @param $files      array
  * @param $class_name string
  * @return mixed
  * @todo factorize
  */
 public function run(Parameters $parameters, $form, $files, $class_name)
 {
     // convert form files to worksheets and session files
     if ($files) {
         /** @var $import Import */
         $import = $parameters->getMainObject(Import::class);
         $import->class_name = $class_name;
         $form = (new Post_Files())->appendToForm($form, $files);
         foreach ($form as $file) {
             if ($file instanceof File) {
                 if (!isset($session_files)) {
                     /** @var $session_files Files */
                     $session_files = Builder::create(Files::class);
                 }
                 $excel = Spreadsheet_File::fileToArray($file->temporary_file_name, $errors);
                 $worksheet_number = 0;
                 foreach ($excel as $temporary_file_name => $worksheet) {
                     if (filesize($temporary_file_name) > 1) {
                         $import_worksheet = Builder::create(Import_Worksheet::class, [$worksheet_number++, Import_Settings_Builder::buildArray($worksheet, $class_name), $csv_file = Builder::create(File::class, [$temporary_file_name])]);
                         $import_worksheet->errors = $errors;
                         $session_files->files[] = $csv_file;
                         $import->worksheets[] = $import_worksheet;
                     }
                 }
                 // only one file once
                 break;
             }
         }
         if (isset($session_files)) {
             Session::current()->set($session_files);
         }
     } else {
         /** @var $files File[] */
         $files = Session::current()->get(Files::class)->files;
         $parameters->unshift($import = Import_Builder_Form::build($form, $files));
         $import->class_name = $class_name;
     }
     // prepare parameters
     $parameters = $parameters->getObjects();
     $general_buttons = $this->getGeneralButtons($class_name);
     if (isset($parameters['constant_remove']) && strtoupper($parameters['constant_remove'][0]) === $parameters['constant_remove'][0]) {
         $parameters['constant_remove'] = rParse($parameters['constant_remove'], DOT);
     }
     foreach ($import->worksheets as $worksheet) {
         // apply controller parameters
         if (isset($parameters['constant_add']) && isset($worksheet->settings->classes[$parameters['constant_add']])) {
             $worksheet->settings->classes[$parameters['constant_add']]->addConstant();
         }
         if (isset($parameters['constant_remove']) && isset($worksheet->settings->classes[lLastParse($parameters['constant_remove'], DOT, 1, false)])) {
             $worksheet->settings->classes[lLastParse($parameters['constant_remove'], DOT, 1, false)]->removeConstant(rLastParse($parameters['constant_remove'], DOT, 1, true));
         }
         Custom_Settings_Controller::applyParametersToCustomSettings($worksheet->settings, array_merge($form, $parameters));
     }
     // recover empty Import_Settings (after loading empty one)
     /** @var $files File[] */
     $files = Session::current()->get(Files::class)->files;
     foreach ($import->worksheets as $worksheet_number => $worksheet) {
         if (empty($worksheet->settings->classes)) {
             $file = $files[$worksheet_number];
             $array = $file->getCsvContent();
             $import->worksheets[$worksheet_number] = new Import_Worksheet($worksheet_number, Import_Settings_Builder::buildArray($array, $class_name), $file);
         }
     }
     // get general buttons and customized import settings
     foreach ($import->worksheets as $worksheet_number => $worksheet) {
         $customized_import_settings = $worksheet->settings->getCustomSettings();
         $worksheet_general_buttons = $general_buttons;
         if (!isset($customized_import_settings[$worksheet->settings->name])) {
             unset($worksheet_general_buttons['delete']);
         }
         $parameters['custom'][$worksheet_number] = new StdClass();
         $parameters['custom'][$worksheet_number]->customized_lists = $customized_import_settings;
         $parameters['custom'][$worksheet_number]->general_buttons = $worksheet_general_buttons;
         $parameters['custom'][$worksheet_number]->settings = $worksheet->settings;
         $parameters['custom'][$worksheet_number]->aliases_property = Import_Array::getPropertiesAlias($worksheet->settings->getClassName());
         $parameters['custom'][$worksheet_number]->properties_alias = array_flip($parameters['custom'][$worksheet_number]->aliases_property);
     }
     // view
     $parameters[Template::TEMPLATE] = 'importPreview';
     return View::run($parameters, $form, $files, $class_name, Feature::F_IMPORT);
 }