Get an instance of permissao_administrativa services facade.
177400
def create_permissao_administrativa(self):
        """"""
        return PermissaoAdministrativa(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
413120
def portalAdmin(self):
        """"""
        from ..manageportal import PortalAdministration
        return PortalAdministration(admin_url="https://%s/portaladmin" % self.portalHostname,
                                    securityHandler=self._securityHandler,
                                    proxy_url=self._proxy_url,
                                    proxy_port=self._proxy_port,
                                    initalize=False)
928100
public function create(): IAuthorizator
	{
		$key = 'AuthorizatorCache';
		$result = $this->cache->load($key);
		if ($result === null) {
			$result = $this->cache->save($key, function () {
				$permission = new Permission;

				$this->createRoles($permission);
				$this->createResource($permission);
				$this->createRules($permission);

				// povoleni vsech prav pro superadmina
				$permission->allow(AclRolesMapper::SUPERADMIN);

				return $permission;
			}, [
				Cache::TAGS => [$this->tag]
			]);
		}
		return $result;
	}
569506
protected function getIdsOfServicesThatAreDefinedInApplication()
    {
        if ($this->serviceIdWhitelist === null) {
            $builder = $this->createContainerBuilder();
            $this->applyToExtensions(function (ExtensionInterface $extension) use ($builder) {
                $extension->load($builder->getExtensionConfig($extension->getAlias()), $builder);
            });
            $this->serviceIdWhitelist = $builder->getServiceIds();
        }
        return $this->serviceIdWhitelist;
    }
124630
def _get_provider_manager(self, osid, local=False):
        """"""
        return get_provider_manager(osid,
                                    runtime=self._runtime,
                                    proxy=getattr(self, '_proxy', None),
                                    local=local)
190838
public function build(): ConsulEnvManager
    {
        $kv = (new ServiceFactory([
            'base_uri' => $this->consulServer
        ]))->get('kv');

        $manager = new ConsulEnvManager(
            $kv,
            $this->overwriteEvenIfDefined
        );

        $this->clear();

        return $manager;
    }
564797
public function getInstance($id)
    {
        if (!\in_array($id, $this->adminServiceIds, true)) {
            $msg = sprintf('Admin service "%s" not found in admin pool.', $id);
            $shortest = -1;
            $closest = null;
            $alternatives = [];
            foreach ($this->adminServiceIds as $adminServiceId) {
                $lev = levenshtein($id, $adminServiceId);
                if ($lev <= $shortest || $shortest < 0) {
                    $closest = $adminServiceId;
                    $shortest = $lev;
                }
                if ($lev <= \strlen($adminServiceId) / 3 || false !== strpos($adminServiceId, $id)) {
                    $alternatives[$adminServiceId] = $lev;
                }
            }
            if (null !== $closest) {
                asort($alternatives);
                unset($alternatives[$closest]);
                $msg = sprintf(
                    'Admin service "%s" not found in admin pool. Did you mean "%s" or one of those: [%s]?',
                    $id,
                    $closest,
                    implode(', ', array_keys($alternatives))
                );
            }
            throw new \InvalidArgumentException($msg);
        }

        $admin = $this->container->get($id);

        if (!$admin instanceof AdminInterface) {
            throw new InvalidArgumentException(sprintf('Found service "%s" is not a valid admin service', $id));
        }

        return $admin;
    }
175495
private function loadServiceProvider()
    {
        \Tiga\Framework\Facade\Facade::setFacadeContainer($this);

        // Available Provider
        $providers = $this['config']->get('provider');

        $providers = array_unique($providers);

        foreach ($providers as $provider) {
            $instance = new $provider($this);
            $instance->register();
        }

        // Aliases
        $aliases = $this['config']->get('alias');

        $aliases = array_unique($aliases);

        $aliasMapper = \Tonjoo\Almari\AliasMapper::getInstance();

        $aliasMapper->classAlias($aliases);
    }
1210036
public function serviceCredentials()
    {
        if (!isset($this->creds)) {
            $filepath = $this->getCredentialsFilepath();
            $this->creds = Json::parseFile($filepath);
        }
        return $this->creds;
    }
440800
public function build(): StartObservingRequest
	{
		$instance = new StartObservingRequest();
		if ($this->service === null) {
			throw new BuilderException('Property [service] is required.');
		}
		$instance->service = $this->service;
		return $instance;
	}
537518
def enviar_dados_venda(self, dados_venda):
        
        retorno = super(ClienteSATLocal, self).enviar_dados_venda(dados_venda)
        return RespostaEnviarDadosVenda.analisar(retorno)
1132581
public function getServicePluginManager()
	{
	    if($this->servicePluginManager === null){
	        $this->servicePluginManager = new ServicePluginManager();
	        $that = $this;
	
	        $this->servicePluginManager->addInitializer(function ($instance, $serviceManager) use ($that) {
	             
	            $name     = $serviceManager->getCreationInstanceName();
	            $options  = $serviceManager->getCreationInstanceOptions();
	             
	            /**
	             * Configure service
	            */
	            if($options !== null && sizeof($options) &&
	               $instance instanceof Feature\ConfigurableInterface){
	
	                $instance->setConfig($options);
	            }
	        });
	    }
	     
	    return $this->servicePluginManager;
	}
1156104
public function getServiceIds()
    {
        return array_unique(array_merge(['service_container'], array_keys($this->fileMap), array_keys($this->methodMap), array_keys($this->services)));
    }
84215
public function getAdminThemeService()
    {
        if (null === $this->adminActionService) {
            $this->adminActionService = $this->getServiceLocator()->get('playgrounddesign_theme_service');
        }

        return $this->adminActionService;
    }
1286289
public static function getInstance() {
    if(self::$DebugLevel >= Web2All_Manager_Main::DEBUGLEVEL_FULL) {
      echo "[Vraag een instantie van de Web2All_Manager_Registry Class op]<br />\n";
    }
    if (!Web2All_Manager_Registry::$instance) {
      Web2All_Manager_Registry::$instance = new Web2All_Manager_Registry;
    }
    return Web2All_Manager_Registry::$instance;
  }
271593
public function create()
    {
        if ($this->reflectionService !== null) {
            return $this->reflectionService;
        }

        $cacheManager = $this->bootstrap->getEarlyInstance(CacheManager::class);
        $configurationManager = $this->bootstrap->getEarlyInstance(ConfigurationManager::class);
        $settings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Neos.Flow');

        $reflectionService = new ReflectionService();
        $reflectionService->injectLogger($this->bootstrap->getEarlyInstance(PsrLoggerFactoryInterface::class)->get('systemLogger'));
        $reflectionService->injectSettings($settings);
        $reflectionService->injectPackageManager($this->bootstrap->getEarlyInstance(PackageManager::class));
        $reflectionService->setStatusCache($cacheManager->getCache('Flow_Reflection_Status'));
        $reflectionService->setReflectionDataCompiletimeCache($cacheManager->getCache('Flow_Reflection_CompiletimeData'));
        $reflectionService->setReflectionDataRuntimeCache($cacheManager->getCache('Flow_Reflection_RuntimeData'));
        $reflectionService->setClassSchemataRuntimeCache($cacheManager->getCache('Flow_Reflection_RuntimeClassSchemata'));
        $reflectionService->injectEnvironment($this->bootstrap->getEarlyInstance(Environment::class));

        $this->reflectionService = $reflectionService;
        return $reflectionService;
    }
255181
protected function getLimitationService()
    {
        if ($this->limitationService !== null) {
            return $this->limitationService;
        }

        $this->limitationService = new Helper\LimitationService($this->serviceSettings['role']);

        return $this->limitationService;
    }