Updates the Aco Tree with all App controllers.

@param \Acl\Model\Entity\Aco $root The root note of Aco Tree
@return void
357299
protected function _processControllers($root)
    {
        $controllers = $this->getControllerList();
        $this->foundACOs[$root->id] = $this->_updateControllers($root, $controllers);
    }
278198
protected function applyRootCondition(&$condition)
    {
        if (false !== $this->rootAttribute) {
            $condition[] = [$this->rootAttribute => $this->node->{$this->rootAttribute}];
        }
    }
1336020
function (root) {
      if (root.refresh) {
        root.refresh()
        return
      }
      for (var i = 0; i < root.children.length; i++) {
        refreshTree(root.children[i])
      }
    }
1070600
protected function update($entity)
    {
        // If this entity was a child of aggregate roots, then call its methods to set the aggregate root Id
        $this->entityRegistry->runAggregateRootCallbacks($entity);
        $dataMapper = $this->getDataMapper($this->entityRegistry->getClassName($entity));
        $dataMapper->update($entity);
        $this->entityRegistry->registerEntity($entity);
    }
1231144
public function updating(Eloquent $model): void
    {
        $original = $model->getOriginal('name');
        $current = $model->getAttribute('name');

        if ($this->isRestoringModel($model)) {
            $this->acl->addRole($current);
        } else {
            $this->acl->renameRole($original, $current);
        }
    }
322070
public function delete($key)
    {
        if (isset($this->data[$key])) {
            unset($this->data[$key]);
            $this->root->updated = true;
            $this->root->update();
        }
    }
469758
public function load_controllers($root, $folder = null)
    {
        $current = $root . ($folder ? '/' . $folder : '');
        if (is_dir($current)) {
            $files = scandir($current);
            foreach ($files as $file) {
                if ($file != '.' && $file != '..') {
                    $filename = $current . '/' . $file;
                    $name = $folder . '/' . $file;
                    $ext = substr($file, strrpos($file, '.'));
                    if ($ext == '.php') {
                        if(($class = $this->preCache($filename)) === false) {
                            $class = file_get_php_classes($filename);
                            $this->postCache($filename, $class);
                        }
                        if(count($class) != 0) {
                            $this->controllers[$class[0]] = $folder . '/' . $file;
                            $this->controllers_map[$class[0]] = $root . '/' . $folder . '/' . $file;
                        } else {
                            Log::w($filename . " is not a valid controller!");
                        }
                    } elseif (is_dir($filename)) {
                        $this->load_controllers($root, $name);
                    }
                }
            }
        }
    }
973546
public function updateAction(Request $request, $id)
    {
        $class_name = $this->container->getParameter('acs_settings.setting_class');
        $settingmanager = $this->get('acs.setting_manager');
        $user_fields = $settingmanager->loadUserFields();
        $em = $this->getDoctrine()->getManager();

        $entity = $this->get('security.context')->getToken()->getUser();

        if (!$entity) {
            throw $this->createNotFoundException('Unable to find ConfigSetting entity.');
        }

        $editForm = $this->createForm(new ConfigSettingCollectionType($user_fields,$em), $entity);

        $editForm->bind($request);


        $postData = $request->request->get('acs_settings_usersettings');

        if ($editForm->isValid()) {
            if (isset($postData['settings'])) {
                    $settings = $postData['settings'];

                    foreach ($settings as $setting) {
                        $args = array(
                            'user' => $entity->getId(),
                            'setting_key' => $setting['setting_key'],
                        );

                        if(isset($setting['service_id'])){
                            $service = $em->getRepository('ACSACSPanelBundle:Service')->find($setting['service_id']);
                            $args['service'] = $service;
                        }

                        $panelsetting = $em->getRepository('ACSACSPanelBundle:PanelSetting')->findOneBy($args);

                        if ($panelsetting && isset($setting['value'])) {
                            $panelsetting->setValue($setting['value']);
                            $em->persist($panelsetting);
                            $em->flush();
                        }
                    }
                    $em->flush();
            }
            return $this->redirect($this->generateUrl('settings'));
        }

        return $this->render('ACSACSPanelSettingsBundle:ConfigSetting:new.html.twig', array(
            'entity' => $entity,
            'form'   => $editForm->createView(),
        ));
    }
584430
protected function mergeStabilityFlags(
        RootPackageInterface $root,
        array $requires
    ) {
        $flags = $root->getStabilityFlags();
        $sf = new StabilityFlags($flags, $root->getMinimumStability());

        $unwrapped = self::unwrapIfNeeded($root, 'setStabilityFlags');
        $unwrapped->setStabilityFlags(array_merge(
            $flags,
            $sf->extractAll($requires)
        ));
    }
1083175
protected function addCommandInPath(string $root)
    {
        $iterator = new DirectoryIterator($root);

        foreach ($iterator as $path) {
            if ($path->isDot()) {
                continue;
            }

            if ($path->isDir()) {
                $this->addCommandInPath($path->getPathName());
            }

            if ($path->isFile() && $path->getExtension() === 'php') {
                if ($command = $this->createCommand($path)) {
                    $this->add($command);
                }
            }
        }

        unset($iterator);
    }
540754
public function index()
    {
        $this->loadModel('User.Acos');
        $roles = $this->Acos->Roles->find()->all();

        $this->title(__d('user', 'User Roles List'));
        $this->set(compact('roles'));
        $this->Breadcrumb
            ->push('/admin/user/manage')
            ->push(__d('user', 'Roles'), ['plugin' => 'User', 'controller' => 'roles', 'action' => 'index']);
    }
222634
public function mergeDevInto(RootPackageInterface $root, PluginState $state)
    {
        $this->mergeRequires('require-dev', $root, $state);
        $this->mergeAutoload('devAutoload', $root);
        $this->mergeReferences($root);
    }
830282
private function mergeAutoload(RootPackageInterface $root)
    {
        if ( ! empty($autoload = $this->getPackage()->getAutoload())) {
            static::unwrapIfNeeded($root, 'setAutoload')
                ->setAutoload(array_merge_recursive(
                    $root->getAutoload(), Util::fixRelativePaths($this->getPath(), $autoload)
                ));
        }
    }
173379
function set_root(Frame $root) {
    $this->_root = $root;
      if ( $this->_frame instanceof Frame_Decorator )
        $this->_frame->set_root($root);
  }
1367890
public function run(): void
    {
        // Set default privacy settings for new trees
        foreach (self::DEFAULT_RESTRICTIONS as $tag_type => $resn) {
            DB::table('default_resn')->updateOrInsert([
                'gedcom_id' => -1,
                'tag_type'  => $tag_type,
            ], [
                'resn'      => $resn,
            ]);
        }
    }
1112497
public function validate(Speak $root)
    {
        $this->validateAllowed($root);
        $this->validateElement($root);

        foreach ($root->getIterator() as $el) {
            $this->validateElement($el);
        }
    }
188827
public function actionUpdate()
    {
        foreach ($this->repos as $repo) {
            $this->rebaseRepo($repo, $this->getFilesystemRepoPath($repo));
        }
        
        foreach ($this->getConfig(self::CONFIG_VAR_CUSTOMCLONES, []) as $repo => $path) {
            $this->rebaseRepo($repo, $path);
        }
    }