/** * Create a new user * * This command creates a new user which has access to the backend user interface. * * More specifically, this command will create a new user and a new account at the same time. The created account * is, by default, a Neos backend account using the the "Typo3BackendProvider" for authentication. The given username * will be used as an account identifier for that new account. * * If an authentication provider name is specified, the new account will be created for that provider instead. * * Roles for the new user can optionally be specified as a comma separated list. For all roles provided by * Neos, the role namespace "TYPO3.Neos:" can be omitted. * * @param string $username The username of the user to be created, used as an account identifier for the newly created account * @param string $password Password of the user to be created * @param string $firstName First name of the user to be created * @param string $lastName Last name of the user to be created * @param string $department department name of the user to be created * @param string $photo photo name of the user to be created * @param string $roles A comma separated list of roles to assign. Examples: "Editor, Acme.Foo:Reviewer" * @param string $authenticationProvider Name of the authentication provider to use for the new account. Example: "Typo3BackendProvider" * @return void */ public function createPhluCommand($username, $password, $firstName, $lastName, $department, $photo, $roles = null, $authenticationProvider = null) { $user = $this->userService->getUser($username, $authenticationProvider); if ($user instanceof User) { $this->outputLine('The username "%s" is already in use', array($username)); $this->quit(1); } try { if ($roles === null) { $user = $this->userService->createUserPhlu($username, $password, $firstName, $lastName, $department, $photo, null, $authenticationProvider); } else { $roleIdentifiers = Arrays::trimExplode(',', $roles); $user = $this->userService->createUserPhlu($username, $password, $firstName, $lastName, $department, $photo, $roleIdentifiers, $authenticationProvider); } $roleIdentifiers = array(); foreach ($user->getAccounts() as $account) { /** @var Account $account */ foreach ($account->getRoles() as $role) { /** @var Role $role */ $roleIdentifiers[$role->getIdentifier()] = true; } } $roleIdentifiers = array_keys($roleIdentifiers); if (count($roleIdentifiers) === 0) { $this->outputLine('Created user "%s".', array($username)); $this->outputLine('<b>Please note that this user currently does not have any roles assigned.</b>'); } else { $this->outputLine('Created user "%s" and assigned the following role%s: %s.', array($username, count($roleIdentifiers) > 1 ? 's' : '', implode(', ', $roleIdentifiers))); } } catch (\Exception $exception) { $this->outputLine($exception->getMessage()); $this->quit(1); } }
/** * @return void */ protected function initializeView(FluidView $fluidView) { $user = $this->getUserData($this['username']); $excludedProjects = Arrays::trimExplode(',', $this['excludedprojects']); $decodedProjects = $this->getProjectsData($user['id']); $projects = []; foreach ($decodedProjects['objects'] as $project) { if (!in_array($project['slug'], $excludedProjects)) { $projects[] = $project; } } $fluidView->assign('projects', $projects); }
/** * Iterate through the segments of the current request path * find the corresponding module configuration and set controller & action * accordingly * * @param string $value * @return boolean|integer */ protected function matchValue($value) { $format = pathinfo($value, PATHINFO_EXTENSION); if ($format !== '') { $value = substr($value, 0, strlen($value) - strlen($format) - 1); } $segments = Arrays::trimExplode('/', $value); $currentModuleBase = $this->settings['modules']; if ($segments === array() || !isset($currentModuleBase[$segments[0]])) { return self::MATCHRESULT_NOSUCHMODULE; } $modulePath = array(); $level = 0; $moduleConfiguration = null; $moduleController = null; $moduleAction = 'index'; foreach ($segments as $segment) { if (isset($currentModuleBase[$segment])) { $modulePath[] = $segment; $moduleConfiguration = $currentModuleBase[$segment]; if (isset($moduleConfiguration['controller'])) { $moduleController = $moduleConfiguration['controller']; } else { $moduleController = null; } if (isset($moduleConfiguration['submodules'])) { $currentModuleBase = $moduleConfiguration['submodules']; } else { $currentModuleBase = array(); } } else { if ($level === count($segments) - 1) { $moduleMethods = array_change_key_case(array_flip(get_class_methods($moduleController)), CASE_LOWER); if (array_key_exists($segment . 'action', $moduleMethods)) { $moduleAction = $segment; break; } } return self::MATCHRESULT_NOSUCHMODULE; } $level++; } if ($moduleController === null) { return self::MATCHRESULT_NOCONTROLLER; } $this->value = array('module' => implode('/', $modulePath), 'controller' => $moduleController, 'action' => $moduleAction); if ($format !== '') { $this->value['format'] = $format; } return self::MATCHRESULT_FOUND; }
/** * Convert (and optionally filter) code coverage data generated by functional tests, * such that file references inside point not to the code cache inside Data/Temporary/...., * but to the Classes/ directory of the packages. * * <b>Example Usage:</b> * phpunit -c Build/BuildEssentials/FunctionalTests.xml --coverage-php Build/Reports/RawFunctionalTestCoverageReport.php * ./flow codeCoverage:convert Build/Reports/RawFunctionalTestCoverageReport.php Build/Reports/FunctionalTestCoverageReport.php --packages 'Your.Packages,Separated.By.Comma' * * The "--packages" argument is optional; but using it results in a huge speed boost; * as only the classes from the specified packages are included in the coverage result. * * @param string $codeCoverageFile Path to the code coverage file generated with "--coverage-php" of phpunit. * @param string $outFile Path to the converted code coverage file * @param string $packages The comma-separated list of packages to filter for. These packages must be installed here. * @param string $context The Flow context which has been used during the functional test run. Only needs to be modified if tests are ran in a special context. */ public function convertCommand($codeCoverageFile, $outFile, $packages = '*', $context = 'Testing') { // Load $packages which should be taken into account while conversion $packageKeys = $packages; if ($packageKeys === '*') { $packages = $this->packageManager->getActivePackages(); } else { $packages = array(); foreach (\TYPO3\Flow\Utility\Arrays::trimExplode(',', $packageKeys) as $packageKey) { $packages[] = $this->packageManager->getPackage($packageKey); } } // For all $packages which should be used, build up a "cache-file-name" -> "real-file-name" mapping. $reverseIndexOfCacheFileNamesToClassFiles = array(); foreach ($packages as $package) { /* @var $package \TYPO3\Flow\Package\PackageInterface */ foreach ($package->getClassFiles() as $className => $fileName) { $cacheFileName = str_replace('\\', '_', $className); $reverseIndexOfCacheFileNamesToClassFiles[$cacheFileName] = $package->getPackagePath() . $fileName; } } // Modify the coverage report /* @var $coverage \Php_CodeCoverage */ $coverage = unserialize(file_get_contents($codeCoverageFile)); $coverageData = $coverage->getData(); $baseDirectoryLength = strlen(FLOW_PATH_ROOT . 'Data/Temporary/' . $context . '/Cache/Code/Flow_Object_Classes/'); $adjustedCoverageData = array(); foreach ($coverageData as $fullCacheFileName => $coverageDataForFile) { $shortCacheFileName = substr($fullCacheFileName, $baseDirectoryLength, -4); if (isset($reverseIndexOfCacheFileNamesToClassFiles[$shortCacheFileName])) { $classFileInPackage = $reverseIndexOfCacheFileNamesToClassFiles[$shortCacheFileName]; $numberOfLinesOfFile = count(file($classFileInPackage)); if (isset($adjustedCoverageData[$classFileInPackage])) { throw new \Sandstorm\Fuzzer\Exception('Coverage data already found for class file "' . $classFileInPackage . '". This should never happen; so we do not override it. It is probably a bug in Fuzzer.', 1367238729); } $adjustedCoverageData[$classFileInPackage] = array(); foreach ($coverageDataForFile as $lineNumber => $coveredBy) { if ($lineNumber <= $numberOfLinesOfFile) { $adjustedCoverageData[$classFileInPackage][$lineNumber] = $coveredBy; } } } } // Save the new coverage report $adjustedCoverage = new PhpunitCodeCoverage(); $adjustedCoverage->setData($adjustedCoverageData); $adjustedCoverage->setTests($coverage->getTests()); file_put_contents($outFile, serialize($adjustedCoverage)); }
/** * @param mixed $includeFields */ public function setIncludeFields($includeFields) { if (is_array($includeFields)) { $includeFields = join(',', $includeFields); } $this->includeFields = array(); if (is_string($includeFields)) { foreach (Arrays::trimExplode(',', $includeFields) as $includeField) { if (!$includeField) { continue; } $this->includeFields[$includeField] = $includeField; } } }
/** * @param mixed $sparseFields */ public function setSparseFields($sparseFields) { if (is_array($sparseFields)) { $sparseFields = join(',', $sparseFields); } $this->sparseFields = array(); if (is_string($sparseFields)) { foreach (Arrays::trimExplode(',', $sparseFields) as $sparseField) { if (!$sparseField) { continue; } $this->sparseFields[$sparseField] = $sparseField; } } }
public function compileSchema() { $schema = (array) $this->configurationManager->getConfiguration('Expose', $this->className); SettingsValidator::validate($schema, $this->supportedClassSettings); if (isset($schema['properties'])) { foreach ($schema['properties'] as $propertyName => $propertySettings) { SettingsValidator::validate($propertySettings, $this->supportedPropertySettings); } } $arrayKeys = array('listProperties', 'searchProperties', 'filterProperties'); foreach ($arrayKeys as $key) { if (isset($schema[$key]) && is_string($schema[$key])) { $schema[$key] = Arrays::trimExplode(',', $schema[$key]); } } return $schema; }
/** * @param array $humanReadableContextProperties * @param boolean $addDimensionDefaults * @return \TYPO3\TYPO3CR\Domain\Service\Context */ protected function getContextForProperties(array $humanReadableContextProperties, $addDimensionDefaults = FALSE) { /** @var \TYPO3\TYPO3CR\Domain\Service\ContextFactoryInterface $contextFactory */ $contextFactory = $this->objectManager->get('TYPO3\\TYPO3CR\\Domain\\Service\\ContextFactoryInterface'); $contextProperties = array(); if (isset($humanReadableContextProperties['Locale'])) { $contextProperties['dimensions']['locales'] = array($humanReadableContextProperties['Locale'], 'mul_ZZ'); } if (isset($humanReadableContextProperties['Locales'])) { $contextProperties['dimensions']['locales'] = Arrays::trimExplode(',', $humanReadableContextProperties['Locales']); } if (isset($humanReadableContextProperties['Workspace'])) { $contextProperties['workspaceName'] = $humanReadableContextProperties['Workspace']; } foreach ($humanReadableContextProperties as $propertyName => $propertyValue) { // Set flexible dimensions from features if (strpos($propertyName, 'Dimension: ') === 0) { $contextProperties['dimensions'][substr($propertyName, strlen('Dimension: '))] = Arrays::trimExplode(',', $propertyValue); } if (strpos($propertyName, 'Target dimension: ') === 0) { $contextProperties['targetDimensions'][substr($propertyName, strlen('Target dimension: '))] = $propertyValue; } } if ($addDimensionDefaults) { $contentDimensionRepository = $this->objectManager->get('TYPO3\\TYPO3CR\\Domain\\Repository\\ContentDimensionRepository'); $availableDimensions = $contentDimensionRepository->findAll(); foreach ($availableDimensions as $dimension) { if (isset($contextProperties['dimensions'][$dimension->getIdentifier()]) && !in_array($dimension->getDefault(), $contextProperties['dimensions'][$dimension->getIdentifier()])) { $contextProperties['dimensions'][$dimension->getIdentifier()][] = $dimension->getDefault(); } } } return $contextFactory->create($contextProperties); }
/** * A method which runs the task implemented by the plugin for the given command * * @param string $controllerCommandName Name of the command in question, for example "repair" * @param ConsoleOutput $output An instance of ConsoleOutput which can be used for output or dialogues * @param NodeType $nodeType Only handle this node type (if specified) * @param string $workspaceName Only handle this workspace (if specified) * @param boolean $dryRun If TRUE, don't do any changes, just simulate what you would do * @param boolean $cleanup If FALSE, cleanup tasks are skipped * @param string $skip Skip the given check or checks (comma separated) * @param string $only Only execute the given check or checks (comma separated) * @return void */ public function invokeSubCommand($controllerCommandName, ConsoleOutput $output, NodeType $nodeType = null, $workspaceName = 'live', $dryRun = false, $cleanup = true, $skip = null, $only = null) { $this->output = $output; $commandMethods = ['removeAbstractAndUndefinedNodes' => ['cleanup' => true], 'removeOrphanNodes' => ['cleanup' => true], 'removeDisallowedChildNodes' => ['cleanup' => true], 'removeUndefinedProperties' => ['cleanup' => true], 'removeBrokenEntityReferences' => ['cleanup' => true], 'removeNodesWithInvalidDimensions' => ['cleanup' => true], 'removeNodesWithInvalidWorkspace' => ['cleanup' => true], 'fixNodesWithInconsistentIdentifier' => ['cleanup' => false], 'createMissingChildNodes' => ['cleanup' => false], 'reorderChildNodes' => ['cleanup' => false], 'addMissingDefaultValues' => ['cleanup' => false], 'repairShadowNodes' => ['cleanup' => false]]; $skipCommandNames = Arrays::trimExplode(',', $skip === null ? '' : $skip); $onlyCommandNames = Arrays::trimExplode(',', $only === null ? '' : $only); switch ($controllerCommandName) { case 'repair': foreach ($commandMethods as $commandMethodName => $commandMethodConfiguration) { if (in_array($commandMethodName, $skipCommandNames)) { continue; } if ($onlyCommandNames !== [] && !in_array($commandMethodName, $onlyCommandNames)) { continue; } if (!$cleanup && $commandMethodConfiguration['cleanup']) { continue; } $this->{$commandMethodName}($workspaceName, $dryRun, $nodeType); } } }
/** * * * @param array $humanReadableContextProperties * @param boolean $addDimensionDefaults * @return \TYPO3\TYPO3CR\Domain\Service\Context * @throws Exception */ protected function getContextForProperties(array $humanReadableContextProperties, $addDimensionDefaults = false) { if ($this->isolated === true) { $this->callStepInSubProcess(__METHOD__, sprintf(' %s %s %s %s', 'string', escapeshellarg($humanReadableContextProperties), 'integer', escapeshellarg($addDimensionDefaults))); } else { /** @var \TYPO3\TYPO3CR\Domain\Service\ContextFactoryInterface $contextFactory */ $contextFactory = $this->getObjectManager()->get('TYPO3\\TYPO3CR\\Domain\\Service\\ContextFactoryInterface'); $contextProperties = array(); if (isset($humanReadableContextProperties['Language'])) { $contextProperties['dimensions']['language'] = array($humanReadableContextProperties['Language'], 'mul_ZZ'); } if (isset($humanReadableContextProperties['Language'])) { $contextProperties['dimensions']['language'] = Arrays::trimExplode(',', $humanReadableContextProperties['Language']); } if (isset($humanReadableContextProperties['Workspace'])) { $contextProperties['workspaceName'] = $humanReadableContextProperties['Workspace']; $this->createWorkspaceIfNeeded($contextProperties['workspaceName']); } else { $this->createWorkspaceIfNeeded(); } foreach ($humanReadableContextProperties as $propertyName => $propertyValue) { // Set flexible dimensions from features if (strpos($propertyName, 'Dimension: ') === 0) { $contextProperties['dimensions'][substr($propertyName, strlen('Dimension: '))] = Arrays::trimExplode(',', $propertyValue); } if (strpos($propertyName, 'Target dimension: ') === 0) { $contextProperties['targetDimensions'][substr($propertyName, strlen('Target dimension: '))] = $propertyValue; } } if ($addDimensionDefaults) { $contentDimensionRepository = $this->getObjectManager()->get('TYPO3\\TYPO3CR\\Domain\\Repository\\ContentDimensionRepository'); $availableDimensions = $contentDimensionRepository->findAll(); foreach ($availableDimensions as $dimension) { if (isset($contextProperties['dimensions'][$dimension->getIdentifier()]) && !in_array($dimension->getDefault(), $contextProperties['dimensions'][$dimension->getIdentifier()])) { $contextProperties['dimensions'][$dimension->getIdentifier()][] = $dimension->getDefault(); } } } return $contextFactory->create($contextProperties); } }
/** * Shows a list of all defined privilege targets and the effective permissions * * @param string $privilegeType The privilege type ("entity", "method" or the FQN of a class implementing PrivilegeInterface) * @param string $roles A comma separated list of role identifiers. Shows policy for an unauthenticated user when left empty. */ public function showEffectivePolicyCommand($privilegeType, $roles = '') { $systemRoleIdentifiers = array('TYPO3.Flow:Everybody', 'TYPO3.Flow:Anonymous', 'TYPO3.Flow:AuthenticatedUser'); if (strpos($privilegeType, '\\') === false) { $privilegeType = sprintf('\\TYPO3\\Flow\\Security\\Authorization\\Privilege\\%s\\%sPrivilegeInterface', ucfirst($privilegeType), ucfirst($privilegeType)); } if (!class_exists($privilegeType) && !interface_exists($privilegeType)) { $this->outputLine('The privilege type "%s" was not defined.', array($privilegeType)); $this->quit(1); } if (!is_subclass_of($privilegeType, PrivilegeInterface::class)) { $this->outputLine('"%s" does not refer to a valid Privilege', array($privilegeType)); $this->quit(1); } $requestedRoles = array(); foreach (Arrays::trimExplode(',', $roles) as $roleIdentifier) { try { if (in_array($roleIdentifier, $systemRoleIdentifiers)) { continue; } $currentRole = $this->policyService->getRole($roleIdentifier); $requestedRoles[$roleIdentifier] = $currentRole; foreach ($currentRole->getAllParentRoles() as $currentParentRole) { if (!in_array($currentParentRole, $requestedRoles)) { $requestedRoles[$currentParentRole->getIdentifier()] = $currentParentRole; } } } catch (NoSuchRoleException $exception) { $this->outputLine('The role %s was not defined.', array($roleIdentifier)); $this->quit(1); } } if (count($requestedRoles) > 0) { $requestedRoles['TYPO3.Flow:AuthenticatedUser'] = $this->policyService->getRole('TYPO3.Flow:AuthenticatedUser'); } else { $requestedRoles['TYPO3.Flow:Anonymous'] = $this->policyService->getRole('TYPO3.Flow:Anonymous'); } $requestedRoles['TYPO3.Flow:Everybody'] = $this->policyService->getRole('TYPO3.Flow:Everybody'); $this->outputLine('Effective Permissions for the roles <b>%s</b> ', array(implode(', ', $requestedRoles))); $this->outputLine(str_repeat('-', $this->output->getMaximumLineLength())); $definedPrivileges = $this->policyService->getAllPrivilegesByType($privilegeType); $permissions = array(); /** @var PrivilegeInterface $definedPrivilege */ foreach ($definedPrivileges as $definedPrivilege) { $accessGrants = 0; $accessDenies = 0; $permission = 'ABSTAIN'; /** @var Role $requestedRole */ foreach ($requestedRoles as $requestedRole) { $privilegeType = $requestedRole->getPrivilegeForTarget($definedPrivilege->getPrivilegeTarget()->getIdentifier()); if ($privilegeType === null) { continue; } if ($privilegeType->isGranted()) { $accessGrants++; } elseif ($privilegeType->isDenied()) { $accessDenies++; } } if ($accessDenies > 0) { $permission = '<error>DENY</error>'; } if ($accessGrants > 0 && $accessDenies === 0) { $permission = '<success>GRANT</success>'; } $permissions[$definedPrivilege->getPrivilegeTarget()->getIdentifier()] = $permission; } ksort($permissions); foreach ($permissions as $privilegeTargetIdentifier => $permission) { $formattedPrivilegeTargetIdentifier = wordwrap($privilegeTargetIdentifier, $this->output->getMaximumLineLength() - 10, PHP_EOL . str_repeat(' ', 10), true); $this->outputLine('%-70s %s', array($formattedPrivilegeTargetIdentifier, $permission)); } }
/** * */ public function initializeAction() { $this->relationshipIterator->setSupportedMediaTypes($this->supportedMediaTypes); if ($this->request->hasArgument('include')) { $include = Arrays::trimExplode(',', $this->request->getArgument('include')); $this->relationshipIterator->setInclude($include); } if ($this->request->hasArgument('fields')) { $fields = array(); foreach ((array) $this->request->getArgument('fields') as $typeName => $fieldsList) { $fields[$typeName] = Arrays::trimExplode(',', $fieldsList); } $this->relationshipIterator->setFields($fields); } }
/** * @Then /^I can (not )?call the method "([^"]*)" of class "([^"]*)"(?: with arguments "([^"]*)")?$/ */ public function iCanCallTheMethodOfClassWithArguments($not, $methodName, $className, $arguments = '') { if ($this->isolated === true) { $this->callStepInSubProcess(__METHOD__, sprintf(' %s %s %s %s %s %s %s %s', 'string', escapeshellarg(trim($not)), 'string', escapeshellarg($methodName), 'string', escapeshellarg($className), 'string', escapeshellarg($arguments))); } else { $this->setupSecurity(); $instance = $this->objectManager->get($className); try { $result = call_user_func_array(array($instance, $methodName), Arrays::trimExplode(',', $arguments)); if ($not === 'not') { Assert::fail('Method should not be callable'); } return $result; } catch (\TYPO3\Flow\Security\Exception\AccessDeniedException $exception) { if ($not !== 'not') { throw $exception; } } } }
/** * Updates the given news object * * @param \Lelesys\Plugin\News\Domain\Model\News $news The news to update * @param array $media News media * @param array $file News file * @param array $tags News tags * @param array $relatedLink News related links * @return void */ public function update(\Lelesys\Plugin\News\Domain\Model\News $news, $media, $file, $relatedLink, $tags) { if (!empty($tags['title'])) { $tagsArray = array_unique(\TYPO3\Flow\Utility\Arrays::trimExplode(',', strtolower($tags['title']))); foreach ($tagsArray as $tag) { $existTag = $this->tagService->findTagByName($tag); if (!empty($existTag)) { $newsTags = $news->getTags()->toArray(); if (!in_array($existTag, $newsTags)) { $news->addTags($existTag); } } else { $newTag = new \Lelesys\Plugin\News\Domain\Model\Tag(); $newTag->setTitle($tag); $this->tagService->create($newTag); $news->addTags($newTag); } } } $news->setUpdatedDate(new \DateTime()); $mediaPath = $media; foreach ($mediaPath as $mediaSource) { if (!empty($mediaSource['uuid'])) { $updateAsset = $this->propertyMapper->convert($mediaSource['uuid']['__identity'], '\\TYPO3\\Media\\Domain\\Model\\Image'); $updateAsset->setCaption($mediaSource['caption']); $this->imageRepository->update($updateAsset); } else { if (!empty($mediaSource['resource']['name'])) { $resource = $this->propertyMapper->convert($mediaSource['resource'], 'TYPO3\\Flow\\Resource\\Resource'); $media = new \TYPO3\Media\Domain\Model\Image($resource); $media->setCaption($mediaSource['caption']); $this->imageRepository->add($media); $news->addAssets($media); } } } $filePath = $file; foreach ($filePath as $fileSource) { if (isset($fileSource['uuid'])) { $updateFile = $this->propertyMapper->convert($fileSource['uuid']['__identity'], '\\TYPO3\\Media\\Domain\\Model\\Document'); $updateFile->setTitle($fileSource['title']); $this->assetRepository->update($updateFile); } else { if (!empty($fileSource['resource']['name'])) { $resource = $this->propertyMapper->convert($fileSource['resource'], 'TYPO3\\Flow\\Resource\\Resource'); $file = new \TYPO3\Media\Domain\Model\Document($resource); $file->setTitle($fileSource['title']); $this->assetRepository->add($file); $news->addFiles($file); } } } $related = $relatedLink; foreach ($related as $link) { if (isset($link['uuid'])) { $updateLink = $this->linkService->findById($link['uuid']); $updateLink->setUri($link['relatedUri']); $updateLink->setTitle($link['relatedUriTitle']); $updateLink->setDescription($link['relatedUriDescription']); $updateLink->setHidden($link['hidden']); $this->linkService->update($updateLink); } else { if (!empty($link['relatedUri'])) { $newLink = new \Lelesys\Plugin\News\Domain\Model\Link(); $newLink->setTitle($link['relatedUriTitle']); $newLink->setUri($link['relatedUri']); $newLink->setDescription($link['relatedUriDescription']); $newLink->setHidden($link['hidden']); $this->linkService->create($newLink); $news->addRelatedLinks($newLink); } } } $this->newsRepository->update($news); $this->emitNewsUpdated($news); }
/** * @Given /^the following users exist:$/ */ public function theFollowingUsersExist(TableNode $table) { $rows = $table->getHash(); /** @var \TYPO3\Neos\Domain\Service\UserService $userService */ $userService = $this->objectManager->get(\TYPO3\Neos\Domain\Service\UserService::class); /** @var \TYPO3\Party\Domain\Repository\PartyRepository $partyRepository */ $partyRepository = $this->objectManager->get(\TYPO3\Party\Domain\Repository\PartyRepository::class); /** @var \TYPO3\Flow\Security\AccountRepository $accountRepository */ $accountRepository = $this->objectManager->get(\TYPO3\Flow\Security\AccountRepository::class); foreach ($rows as $row) { $roleIdentifiers = array_map(function ($role) { return 'TYPO3.Neos:' . $role; }, Arrays::trimExplode(',', $row['roles'])); $userService->createUser($row['username'], $row['password'], $row['firstname'], $row['lastname'], $roleIdentifiers); } $this->getSubcontext('flow')->persistAll(); }
/** * @param string $assertionStepsString */ public function setAssertionStepsString($assertionStepsString) { $this->assertionSteps = \TYPO3\Flow\Utility\Arrays::trimExplode(',', $assertionStepsString, TRUE); }
/** * Batch process of the given preset * * @param string $preset * @param string $parts */ public function batchCommand($preset, $parts = NULL) { $this->startTime = microtime(TRUE); $parts = Arrays::trimExplode(',', $parts); $this->outputLine('Start import ...'); $logPrefix = Algorithms::generateRandomString(12); $presetSettings = Arrays::getValueByPath($this->settings, array('presets', $preset)); if (!is_array($presetSettings)) { $this->outputLine(sprintf('Preset "%s" not found ...', $preset)); $this->quit(1); } array_walk($presetSettings, function ($partSetting, $partName) use($preset, $logPrefix, $parts) { $this->elapsedTime = 0; $this->batchCounter = 0; $this->outputLine(); $this->outputFormatted(sprintf('<b>%s</b>', $partSetting['label'])); $partSetting['__currentPresetName'] = $preset; $partSetting['__currentPartName'] = $partName; $partSetting = new PresetPartDefinition($partSetting, $logPrefix); if ($parts !== array() && !in_array($partName, $parts)) { $this->outputLine('Skipped'); return; } if ($partSetting->getBatchSize()) { while (($count = $this->executeCommand($partSetting)) > 0) { $partSetting->nextBatch(); } } else { $this->executeCommand($partSetting); } }); $this->outputLine(); $this->outputLine('Import finished'); }
/** * @param string $serializedLocation * @return array */ public function parseString($serializedLocation) { $location = Arrays::trimExplode(',', $serializedLocation); return ['latitude' => (double) $location[0], 'longitude' => (double) $location[1]]; }
/** * A method which runs the task implemented by the plugin for the given command * * @param string $controllerCommandName Name of the command in question, for example "repair" * @param ConsoleOutput $output An instance of ConsoleOutput which can be used for output or dialogues * @param NodeType $nodeType Only handle this node type (if specified) * @param string $workspaceName Only handle this workspace (if specified) * @param boolean $dryRun If TRUE, don't do any changes, just simulate what you would do * @param boolean $cleanup If FALSE, cleanup tasks are skipped * @param string $skip Skip the given check or checks (comma separated) * @param string $only Only execute the given check or checks (comma separated) * @return void */ public function invokeSubCommand($controllerCommandName, ConsoleOutput $output, NodeType $nodeType = null, $workspaceName = 'live', $dryRun = false, $cleanup = true, $skip = null, $only = null) { $this->output = $output; $commandMethods = ['generateUriPathSegments' => ['cleanup' => false], 'removeContentDimensionsFromRootAndSitesNode' => ['cleanup' => true]]; $skipCommandNames = Arrays::trimExplode(',', $skip === null ? '' : $skip); $onlyCommandNames = Arrays::trimExplode(',', $only === null ? '' : $only); switch ($controllerCommandName) { case 'repair': foreach ($commandMethods as $commandMethodName => $commandMethodConfiguration) { if (in_array($commandMethodName, $skipCommandNames)) { continue; } if ($onlyCommandNames !== [] && !in_array($commandMethodName, $onlyCommandNames)) { continue; } if (!$cleanup && $commandMethodConfiguration['cleanup']) { continue; } $this->{$commandMethodName}($workspaceName, $dryRun, $nodeType); } } }
/** * Outputs a table for given search result * * @param resource $connection * @param resource $searchResult * @param $displayColumns * @return void */ protected function outputLdapSearchResultTable($connection, $searchResult, $displayColumns) { $headers = []; $rows = []; $displayColumns = Arrays::trimExplode(',', $displayColumns); $entries = ldap_get_entries($connection, $searchResult); $this->outputLine('%s results found', [$entries['count']]); foreach ($entries as $index => $ldapSearchResult) { if ($index === 'count') { continue; } if ($headers === []) { foreach ($ldapSearchResult as $propertyName => $propertyValue) { if (is_integer($propertyName)) { continue; } if ($displayColumns === null || in_array($propertyName, $displayColumns)) { $headers[] = $propertyName; } } } $row = []; foreach ($ldapSearchResult as $propertyName => $propertyValue) { if (is_integer($propertyName)) { continue; } if ($displayColumns !== null && !in_array($propertyName, $displayColumns)) { continue; } if (isset($propertyValue['count'])) { unset($propertyValue['count']); } if (is_array($propertyValue)) { $row[$propertyName] = implode(", ", $propertyValue); } else { $row[$propertyName] = $propertyValue; } } $rows[] = $row; } $this->output->outputTable($rows, $headers); }
/** * This method is called when the form of this step has been submitted * * @param array $formValues * @return void */ public function postProcessFormValues(array $formValues) { $settings = $this->configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, 'Lightwerk.SurfCaptain'); $driver = $settings['sources']['default']['driver']; $repositories = Arrays::trimExplode(',', $formValues['repositories']); // reset $this->distributionSettings['Lightwerk']['SurfCaptain']['sources']['default']['repositories'] = array(); for ($i = 0; $i < count($repositories); $i++) { $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.repositories.' . $i, $repositories[$i]); } $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.privateToken', $formValues['privateToken']); switch ($driver) { case 'GitHub': $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.accountName', '*****@*****.**'); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.apiUrl', 'https://api.github.com/'); break; case 'GitLab': $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.accountName', $formValues['accountName']); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.apiUrl', $formValues['apiUrl']); break; case 'BitBucket': $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.accountName', $formValues['accountName']); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.apiUrl', 'https://api.bitbucket.org/2.0/'); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.fallbackApiUrl', 'https://api.bitbucket.org/1.0/'); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.privateSecret', $formValues['privateSecret']); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.accessToken', $formValues['accessToken']); $this->distributionSettings = Arrays::setValueByPath($this->distributionSettings, 'Lightwerk.SurfCaptain.sources.default.accessSecret', $formValues['accessSecret']); break; default: throw new SetupException('Unknown driver ' . $driver, 1427623122); } $this->configurationSource->save(FLOW_PATH_CONFIGURATION . ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $this->distributionSettings); }
/** * Kickstart a new command controller * * Creates a new command controller with the given name in the specified * package. The generated controller class already contains an example command. * * @param string $packageKey The package key of the package for the new controller * @param string $controllerName The name for the new controller. This may also be a comma separated list of controller names. * @param boolean $force Overwrite any existing controller. * @return string * @see typo3.kickstart:kickstart:actioncontroller */ public function commandControllerCommand($packageKey, $controllerName, $force = FALSE) { $this->validatePackageKey($packageKey); if (!$this->packageManager->isPackageAvailable($packageKey)) { $this->outputLine('Package "%s" is not available.', array($packageKey)); exit(2); } $generatedFiles = array(); $controllerNames = \TYPO3\Flow\Utility\Arrays::trimExplode(',', $controllerName); foreach ($controllerNames as $currentControllerName) { $generatedFiles += $this->generatorService->generateCommandController($packageKey, $currentControllerName, $force); } $this->outputLine(implode(PHP_EOL, $generatedFiles)); }
/** * Returns an array of packages that are available for translation. * * The list includes basically every active package * - minus the ones that are excluded in the configuration * - minus the ones that don't have the needed translation files * * @return array all the available packages */ protected function getAvailablePackages() { $allPackages = $this->packageManager->getActivePackages(); // make sure the packages of the framework are excluded depending on our settings $packages = array(); $packagesToExclude = \TYPO3\Flow\Utility\Arrays::trimExplode(',', $this->settings['packagesToExclude']); foreach ($allPackages as $package) { if (!in_array($package->getPackageKey(), $packagesToExclude) && $this->hasXliffFilesInDefaultDirectories($package)) { $packages[] = $package; } } return $packages; }
/** * @param QueryInterface $query * @param $nodeTypeFilter * @return array */ protected function getNodeTypeFilterConstraints(QueryInterface $query, $nodeTypeFilter) { $includeNodeTypeConstraints = array(); $excludeNodeTypeConstraints = array(); $nodeTypeFilterParts = Arrays::trimExplode(',', $nodeTypeFilter); foreach ($nodeTypeFilterParts as $nodeTypeFilterPart) { $nodeTypeFilterPart = trim($nodeTypeFilterPart); if (strpos($nodeTypeFilterPart, '!') === 0) { $negate = true; $nodeTypeFilterPart = substr($nodeTypeFilterPart, 1); } else { $negate = false; } $nodeTypeFilterPartSubTypes = array_merge(array($nodeTypeFilterPart), $this->nodeTypeManager->getSubNodeTypes($nodeTypeFilterPart, false)); foreach ($nodeTypeFilterPartSubTypes as $nodeTypeFilterPartSubType) { if ($negate === true) { $excludeNodeTypeConstraints[] = $query->logicalNot($query->equals('nodeType', $nodeTypeFilterPartSubType)); } else { $includeNodeTypeConstraints[] = $query->equals('nodeType', $nodeTypeFilterPartSubType); } } } $constraints = $excludeNodeTypeConstraints; if (count($includeNodeTypeConstraints) > 0) { $constraints[] = $query->logicalOr($includeNodeTypeConstraints); } return $constraints; }
/** * Updates the profile given in $profileFilename with the tags given in * $tagList (comma-separated tags) and return the tags rendered as HTML. * * @param string $profileFilename * @param string $tagList * @return string */ public function updateTagsAction($profileFilename, $tagList) { $profile = $this->getProfile($profileFilename); $tags = \TYPO3\Flow\Utility\Arrays::trimExplode(',', $tagList); $profile->setTags($tags); $profile->save(); return $this->renderTagsService->render($tags); }
/** * @param string $message * @throws \Exception * @return array */ protected function extractReleases($message) { $pattern = '/Releases:\\s*(.*)/'; preg_match($pattern, $message, $matches); if (!isset($matches[1])) { return ['omitted']; } /** * fix Stuff */ if (strstr($matches[1], 'master.')) { $matches[1] = str_replace('master.', 'master,', $matches[1]); } if (strstr($matches[1], '4.7.')) { $matches[1] = str_replace('4.7.', '4.7,', $matches[1]); } if (strstr($matches[1], '4.5 LTS')) { $matches[1] = str_replace('4.5 LTS', '4.5', $matches[1]); } $releaseArray = Utility\Arrays::trimExplode(',', $matches[1]); foreach ($releaseArray as $key => $release) { if (strstr($release, ' ')) { \TYPO3\Flow\var_dump($releaseArray); throw new \Exception('Release contains space?'); } $releaseArray[$key] = $release; } return $releaseArray; }
/** * * * @param array $humanReadableContextProperties * @param boolean $addDimensionDefaults * @return \TYPO3\TYPO3CR\Domain\Service\Context * @throws Exception */ protected function getContextForProperties(array $humanReadableContextProperties, $addDimensionDefaults = false) { if ($this->isolated === true) { $this->callStepInSubProcess(__METHOD__, sprintf(' %s %s %s %s', 'string', escapeshellarg($humanReadableContextProperties), 'integer', escapeshellarg($addDimensionDefaults))); } else { /** @var \TYPO3\TYPO3CR\Domain\Service\ContextFactoryInterface $contextFactory */ $contextFactory = $this->getObjectManager()->get(\TYPO3\TYPO3CR\Domain\Service\ContextFactoryInterface::class); $contextProperties = array(); if (isset($humanReadableContextProperties['Language'])) { $contextProperties['dimensions']['language'] = Arrays::trimExplode(',', $humanReadableContextProperties['Language']); } if (isset($humanReadableContextProperties['Workspace'])) { $contextProperties['workspaceName'] = $humanReadableContextProperties['Workspace']; $this->createWorkspaceIfNeeded($contextProperties['workspaceName']); } else { $this->createWorkspaceIfNeeded(); } if (isset($humanReadableContextProperties['Hidden'])) { $contextProperties['hidden'] = $humanReadableContextProperties['Hidden']; } foreach ($humanReadableContextProperties as $propertyName => $propertyValue) { // Set flexible dimensions from features if (strpos($propertyName, 'Dimension: ') === 0) { $contextProperties['dimensions'][substr($propertyName, strlen('Dimension: '))] = Arrays::trimExplode(',', $propertyValue); } // FIXME We lack a good API to manipulate dimension values explicitly or assign multiple values, so we are doing this via target dimension values if (strpos($propertyName, 'Target dimension: ') === 0) { if ($propertyValue === '') { $propertyValue = null; } $contextProperties['targetDimensions'][substr($propertyName, strlen('Target dimension: '))] = $propertyValue; } } if ($addDimensionDefaults) { $contentDimensionRepository = $this->getObjectManager()->get(\TYPO3\TYPO3CR\Domain\Repository\ContentDimensionRepository::class); $availableDimensions = $contentDimensionRepository->findAll(); foreach ($availableDimensions as $dimension) { if (isset($contextProperties['dimensions'][$dimension->getIdentifier()]) && !in_array($dimension->getDefault(), $contextProperties['dimensions'][$dimension->getIdentifier()])) { $contextProperties['dimensions'][$dimension->getIdentifier()][] = $dimension->getDefault(); } } } $contextProperties['invisibleContentShown'] = true; return $contextFactory->create($contextProperties); } }
/** * @When /^I create the following accounts:$/ */ public function iCreateTheFollowingAccounts(TableNode $table) { foreach ($table->getHash() as $row) { $user = $this->getObjectManager()->get(UserService::class)->createUser($row['User'], $row['Password'], $row['First Name'], $row['Last Name'], Arrays::trimExplode(',', $row['Roles'])); } $this->getSubcontext('flow')->persistAll(); }
/** * Call an arbitrary method and return the result - or "EXCEPTION: <exception-code>" if an exception occurred * * @Flow\Internal * @param string $className The fully qualified class name * @param string $methodName The method to call * @param string $parameters Comma-separated list of method arguments */ public function callMethodCommand($className, $methodName, $parameters = '') { $instance = $this->objectManager->get($className); try { $result = call_user_func_array(array($instance, $methodName), Arrays::trimExplode(',', $parameters)); } catch (\Exception $exception) { $this->outputLine('EXCEPTION: %s', array($exception->getCode())); return; } $this->output('SUCCESS: %s', array($result)); }