/** * Gets/sets current environment's object * * @param $set_current mixed * @return Current */ public static function current($set_current = null) { $called_class = get_called_class(); // set current (ignore Reflection_Property : to enable use of @default Class::current) if ($set_current && !is_a($set_current, Reflection_Property::class)) { static::$current = $set_current; if (!is_a($called_class, Plugin::class, true)) { Session::current()->set($set_current, Builder::current()->sourceClassName($called_class)); } } elseif (!isset(static::$current)) { // get current plugin from plugins manager if (is_a($called_class, Plugin::class, true)) { if ($called_class === Builder::class) { static::$current = new Builder(); } else { $plugin = Session::current()->plugins->get(Builder::current()->sourceClassName($called_class)); if (!isset(static::$current)) { static::$current = $plugin; } } } else { static::$current = Session::current()->get($called_class); } } return static::$current; }
/** * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { /** @var $session_files Files */ $raw_parameters = $parameters->getRawParameters(); $file_key = reset($raw_parameters); $session_files = Session::current()->get(Files::class); // numeric (session files index) file key if (isset($session_files->files[$file_key])) { $file = $session_files->files[$file_key]; } else { foreach ($session_files->files as $file) { if ($file->name === $file_key) { break; } } } // output if (isset($file)) { header('Content-Type: ' . $file->getType()); if (isset($raw_parameters['size'])) { $image = Image::createFromString($file->content); $image->resize($raw_parameters['size'], $raw_parameters['size'])->display(); } else { echo $file->content; } } }
/** * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { $parameters = $parameters->getObjects(); if (!reset($parameters) instanceof Menu) { array_unshift($parameters, Session::current()->plugins->get(Menu::class)); } return View::run($parameters, $form, $files, Menu::class, Feature::F_OUTPUT); }
/** * @param Application $set_current * @return Application */ public static function current(Application $set_current = null) { if ($set_current) { Session::current()->set($set_current, Application::class); return $set_current; } return Session::current()->get(Application::class); }
public function activate() { /** @var $application_updater Application_Updater */ $application_updater = Session::current()->plugins->get(Application_Updater::class); $application_updater->addUpdatable($this); $this->cache_path = Application::current()->include_path->getSourceDirectory() . '/cache'; /** @noinspection PhpIncludeInspection */ @(include $this->cache_path . '/autoload.php'); if (!$this->paths || !$this->full_class_names || $application_updater->mustUpdate()) { $this->update(); } }
/** * 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; }
/** * This will be called for this controller, always. * * @param $parameters Parameters * @param $form array * @param $files array * @param $class_name string * @return mixed */ public function run(Parameters $parameters, $form, $files, $class_name) { set_time_limit(900); $import = Import_Builder_Form::build($form, Session::current()->get(Files::class)->files); $import->class_name = $class_name; $parameters->getMainObject($import); $parameters = $parameters->getObjects(); foreach ($import->worksheets as $worksheet) { $array = $worksheet->file->getCsvContent(); $import_array = new Import_Array($worksheet->settings, $import->class_name); $import_array->importArray($array); } $parameters[Template::TEMPLATE] = 'importDone'; return View::run($parameters, $form, $files, $class_name, Feature::F_IMPORT); }
/** * This will be called for this controller, always. * * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { $environment = Session::current()->get(Environment::class, true); $objects = $parameters->getObjects(); $set_value = isset($objects['']) ? $objects[''] : (isset($objects[1]) ? $objects[1] : null); $name = $objects[0]; $this->property = (new Reflection_Class($environment))->getProperty($name); if ($set_value) { $type = $this->property->getType(); $environment->{$name} = $type->isClass() ? Dao::read($set_value, $type->asString()) : $set_value; $parameters->set('selected', true); return (new Output_Controller())->run($parameters, $form, $files); } else { $objects['controller'] = $this; $objects['name'] = $name; $objects = array_merge([get_class($environment) => $environment], $objects); return View::run($objects, $form, $files, get_class($environment), Feature::F_SELECT); } }
/** * Includes the php file that contains the given class (must contain namespace) * * @param $class_name string class name (with or without namespace) * @return boolean */ public function autoload($class_name) { if ($i = strrpos($class_name, '\\')) { $namespace = strtolower(str_replace('\\', '/', substr($class_name, 0, $i))); $file_name = substr($class_name, $i + 1); // 'A\Class' stored into 'a/class/Class.php' if (file_exists($file1 = strtolower($namespace . '/' . $file_name) . '/' . $file_name . '.php')) { /** @noinspection PhpIncludeInspection */ $result = (include_once Include_Filter::file($file1)); } elseif (file_exists($file2 = strtolower($namespace) . '/' . $file_name . '.php')) { /** @noinspection PhpIncludeInspection */ $result = (include_once Include_Filter::file($file2)); } else { if (Builder::isBuilt($class_name)) { $file = 'cache/compiled/' . str_replace(SL, '-', Names::classToPath($class_name)); if (file_exists($file)) { /** @noinspection PhpIncludeInspection */ $result = (include_once $file); } } if (!isset($result)) { if (error_reporting()) { trigger_error('Class not found ' . $class_name . ', should be into ' . $file1 . ' or ' . $file2, E_USER_ERROR); } $result = false; } } } else { /** @noinspection PhpIncludeInspection */ $result = (include_once Include_Filter::file($class_name . '.php')); } // instantiate plugin if ($result && class_exists($class_name, false) && is_a($class_name, Plugin::class, true)) { if (Session::current()) { Session::current()->plugins->get($class_name); } } }
/** * @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); }
/** * Returns application name * * @param $template Template * @return string */ public function getApplication(Template $template) { return new Displayable(Session::current()->getApplicationName(), Displayable::TYPE_CLASS); }
/** * Remove current user from script and session * * Call this to disconnect user * * @param $user User */ public static function disconnect(User $user) { User::current(new User()); Session::current()->removeAny(get_class($user)); }
/** * @param $file File * @return Anchor */ protected function buildFileAnchor(File $file) { /** @var $session_files Files */ $session_files = Session::current()->get(Files::class, true); $session_files->files[] = $file; $image = $file->getType()->is('image') ? new Image(View::link(Session_File::class, 'output', [$file->name], ['size' => 22])) : ''; $anchor = new Anchor(View::link(Session_File::class, 'image', [$file->name]), $image . new Span($file->name)); if ($file->getType()->is('image')) { $anchor->setAttribute('target', Target::BLANK); //$anchor->addClass('popup'); } return $anchor; }
/** * @param $sources Reflection_Source[] Key is the file path * @return Reflection_Source[] added sources list */ public function moreSourcesToCompile(&$sources) { $added = []; foreach ($sources as $file_path => $source) { if (!strpos($file_path, SL)) { $reload = true; break; } } if (isset($reload)) { $old_compositions = Builder::current()->getCompositions(); $old_levels = Session::current()->plugins->getAll(true); if (isset(Main::$current)) { Main::$current->resetSession(); } $new_compositions = Builder::current()->getCompositions(); $new_levels = Session::current()->plugins->getAll(true); // add classes where builder composition changed foreach ($old_compositions as $class_name => $old_composition) { if (!isset($new_compositions[$class_name]) || $old_composition != $new_compositions[$class_name] || is_array($old_composition) && (array_diff($old_composition, $new_compositions[$class_name]) || array_diff($new_compositions[$class_name], $old_composition))) { $this->moreSourcesAdd($class_name, $sources, $added); } } foreach ($new_compositions as $class_name => $new_composition) { if (!isset($old_compositions[$class_name])) { $this->moreSourcesAdd($class_name, $sources, $added); } } // add classes of globally added/removed plugins foreach ($old_levels as $level => $old_plugins) { foreach ($old_plugins as $class_name => $old_plugin) { if (!isset($new_levels[$level][$class_name])) { $this->moreSourcesAdd($class_name, $sources, $added); } } } foreach ($new_levels as $level => $new_plugins) { foreach ($new_plugins as $class_name => $new_plugin) { if (!isset($old_levels[$level][$class_name])) { $this->moreSourcesAdd($class_name, $sources, $added); } } } } return $added; }
/** * This will be called for this controller, always. * * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { $environment = Session::current()->get(Environment::class, true); $parameters = array_merge([get_class($environment) => $environment], $parameters->getObjects()); return View::run($parameters, $form, $files, get_class($environment), Feature::F_OUTPUT); }
private function resumeSession() { $plugins = Session::current()->plugins; $plugins->addPlugins('top_core', $this->top_core_plugins); $plugins->activatePlugins('core'); }
/** * Updates all registered updatable objects * * You should prefer call autoUpdate() to update the application only if needed * * @param $main_controller Main */ public function update(Main $main_controller) { $last_update_time = $this->getLastUpdateTime(); if (!isset($this->update_time)) { $this->update_time = time(); } foreach ($this->updatables as $key => $updatable) { if (is_string($updatable)) { $updatable = Session::current()->plugins->get($updatable); $this->updatables[$key] = $updatable; } if ($updatable instanceof Needs_Main) { $updatable->setMainController($main_controller); } $updatable->update($last_update_time); } }
/** * @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); } } }
/** * This will be called for this controller, always. * * @param $parameters Parameters * @param $form array * @param $files array * @return mixed */ public function run(Parameters $parameters, $form, $files) { Session::current()->get(Settings::class, true)->add($parameters->getRawParameter('code'), $parameters->getRawParameter('value')); }
/** * @param $weaver IWeaver If not set, the current weaver plugin is used */ public function __construct(IWeaver $weaver = null) { $this->weaver = $weaver ?: Session::current()->plugins->get(Weaver::class); }
/** * @param $class_name string * @return string */ public function autoload($class_name) { $file_path = $this->getClassFilename($class_name); if ($file_path) { /** @noinspection PhpIncludeInspection */ include_once Include_Filter::file($file_path); // if included file does not contain the good class : will need to scan for the right file if (!class_exists($class_name) && !interface_exists($class_name) && !trait_exists($class_name)) { unset($this->class_paths[$class_name]); $file_path = $this->autoload($class_name); } elseif (Session::current()->plugins->has($class_name)) { Session::current()->plugins->get($class_name); } } return $file_path; }