/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$this->ensureExtensionLoaded('apc');
$regexp = $input->getArgument('regexp');
$user = $this->getCacheTool()->apc_cache_info('user');
$keys = array();
foreach ($user['cache_list'] as $key) {
$string = $key['info'];
if (preg_match('|' . $regexp . '|', $string)) {
$keys[] = $key;
}
}
$cpt = 0;
$table = new Table($output);
$table->setHeaders(array('Key', 'TTL'));
$table->setRows($keys);
$table->render($output);
foreach ($keys as $key) {
$success = $this->getCacheTool()->apc_delete($key['info']);
if ($output->isVerbose()) {
if ($success) {
$output->writeln("<comment>APC key <info>{$key['info']}</info> was deleted</comment>");
} else {
$output->writeln("<comment>APC key <info>{$key['info']}</info> could not be deleted.</comment>");
}
}
$cpt++;
}
if ($output->isVerbose()) {
$output->writeln("<comment>APC key <info>{$cpt}</info> keys treated.</comment>");
}
return 1;
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$templates = [];
foreach ($this->defaults as $name => $defaults) {
$templates[$name] = ['environments' => [], 'scalingProfiles' => []];
}
foreach ($this->environments as $template => $environments) {
foreach ($environments as $name => $options) {
$templates[$template]['environments'][] = $name;
}
}
foreach ($this->scalingProfiles as $template => $scalingProfiles) {
foreach ($scalingProfiles as $name => $options) {
$templates[$template]['scalingProfiles'][] = $name;
}
}
$table = new Table($output);
$table->setHeaders(['Name', 'Environments', 'Scaling profiles']);
$i = 0;
foreach ($templates as $name => $data) {
++$i;
$table->addRow([$name, implode("\n", $data['environments']), implode("\n", $data['scalingProfiles'])]);
if ($i !== count($templates)) {
$table->addRow(new TableSeparator());
}
}
$table->render();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$groupPattern = $input->getArgument('group');
if (empty($groupPattern)) {
$groupPattern = '.*';
}
$cloudwatchLogsClient = \AwsInspector\SdkFactory::getClient('cloudwatchlogs');
/* @var $cloudwatchLogsClient \Aws\CloudWatchLogs\CloudWatchLogsClient */
$table = new Table($output);
$table->setHeaders(['Name', 'Retention [days]', 'Size [MB]']);
$totalBytes = 0;
$nextToken = null;
do {
$params = ['limit' => 50];
if ($nextToken) {
$params['nextToken'] = $nextToken;
}
$result = $cloudwatchLogsClient->describeLogGroups($params);
foreach ($result->get('logGroups') as $logGroup) {
$name = $logGroup['logGroupName'];
if (preg_match('/' . $groupPattern . '/', $name)) {
$table->addRow([$logGroup['logGroupName'], isset($logGroup['retentionInDays']) ? $logGroup['retentionInDays'] : 'Never', round($logGroup['storedBytes'] / (1024 * 1024))]);
$totalBytes += $logGroup['storedBytes'];
}
}
$nextToken = $result->get("nextToken");
} while ($nextToken);
$table->render();
$output->writeln('Total size: ' . $this->formatBytes($totalBytes));
}
protected function checkRequirements()
{
$this->defaultOutput->writeln('<info><comment>Step 1 of 5.</comment> Checking system requirements.</info>');
$fulfilled = true;
$label = '<comment>PDO Driver</comment>';
$status = '<info>OK!</info>';
$help = '';
if (!extension_loaded($this->getContainer()->getParameter('database_driver'))) {
$fulfilled = false;
$status = '<error>ERROR!</error>';
$help = 'Database driver "' . $this->getContainer()->getParameter('database_driver') . '" is not installed.';
}
$rows = [];
$rows[] = [$label, $status, $help];
foreach ($this->functionExists as $functionRequired) {
$label = '<comment>' . $functionRequired . '</comment>';
$status = '<info>OK!</info>';
$help = '';
if (!function_exists($functionRequired)) {
$fulfilled = false;
$status = '<error>ERROR!</error>';
$help = 'You need the ' . $functionRequired . ' function activated';
}
$rows[] = [$label, $status, $help];
}
$table = new Table($this->defaultOutput);
$table->setHeaders(['Checked', 'Status', 'Recommendation'])->setRows($rows)->render();
if (!$fulfilled) {
throw new \RuntimeException('Some system requirements are not fulfilled. Please check output messages and fix them.');
}
$this->defaultOutput->writeln('<info>Success! Your system can run Wallabag properly.</info>');
$this->defaultOutput->writeln('');
return $this;
}
protected function execute(InputInterface $input, OutputInterface $output) : int
{
if (!$output->isQuiet()) {
$output->writeln($this->getApplication()->getLongVersion());
}
$composerJson = $input->getArgument('composer-json');
$this->checkJsonFile($composerJson);
$getPackageSourceFiles = new LocateComposerPackageSourceFiles();
$sourcesASTs = new LocateASTFromFiles((new ParserFactory())->create(ParserFactory::PREFER_PHP7));
$definedVendorSymbols = (new LocateDefinedSymbolsFromASTRoots())->__invoke($sourcesASTs((new ComposeGenerators())->__invoke($getPackageSourceFiles($composerJson), (new LocateComposerPackageDirectDependenciesSourceFiles())->__invoke($composerJson))));
$options = $this->getCheckOptions($input);
$definedExtensionSymbols = (new LocateDefinedSymbolsFromExtensions())->__invoke((new DefinedExtensionsResolver())->__invoke($composerJson, $options->getPhpCoreExtensions()));
$usedSymbols = (new LocateUsedSymbolsFromASTRoots())->__invoke($sourcesASTs($getPackageSourceFiles($composerJson)));
$unknownSymbols = array_diff($usedSymbols, $definedVendorSymbols, $definedExtensionSymbols, $options->getSymbolWhitelist());
if (!$unknownSymbols) {
$output->writeln("There were no unknown symbols found.");
return 0;
}
$output->writeln("The following unknown symbols were found:");
$table = new Table($output);
$table->setHeaders(['unknown symbol', 'guessed dependency']);
$guesser = new DependencyGuesser();
foreach ($unknownSymbols as $unknownSymbol) {
$guessedDependencies = [];
foreach ($guesser($unknownSymbol) as $guessedDependency) {
$guessedDependencies[] = $guessedDependency;
}
$table->addRow([$unknownSymbol, implode("\n", $guessedDependencies)]);
}
$table->render();
return (int) (bool) $unknownSymbols;
}
/**
* @{inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$this->classContentManager = $this->getApplication()->getApplication()->getContainer()->get('classcontent.manager');
$this->classContents = $this->classContentManager->getAllClassContentClassnames();
/*
* @todo: better to use isEnabled to hide this function if no class contents were found ?
*/
if (!is_array($this->classContents) || count($this->classContents) <= 0) {
throw new \LogicException('You don`t have any Class content in application');
}
if ($input->getArgument('classname')) {
$output->writeln($this->describeClassContent($input->getArgument('classname')));
return;
}
$output->writeln($this->getHelper('formatter')->formatSection('Class Contents', 'List of available Class Contents'));
$output->writeln('');
$headers = array('Name', 'Classname');
$table = new Table($output);
$table->setHeaders($headers)->setStyle('compact');
foreach ($this->classContents as $classContent) {
$instance = new $classContent();
$table->addRow([$instance->getProperty('name'), $classContent]);
}
$table->render();
}
/**
* instala arquivos do tema se tiver na extensao
* @param $extension
* @param $output
*/
private function installThemeFiles($extension, $output)
{
$theme_files = Util::getFilesTheme($extension);
if (count($theme_files)) {
$table = new Table($output);
$table->setHeaders(array('Theme Files'));
$themes = Util::getThemesPath();
foreach ($themes as $theme) {
foreach ($theme_files as $theme_file) {
$dest = str_replace($extension . '/theme/', $theme . '/', $theme_file);
$dir = dirname($dest);
if (!is_dir($dir)) {
mkdir($dir, 0755, true);
}
if (!file_exists($dest)) {
$table->addRow(['<info>' . $dest . '</info>']);
} else {
$table->addRow(['<comment>' . $dest . '</comment>']);
}
@copy($theme_file, $dest);
}
}
$table->render();
}
}
/**
* @param InputInterface $input
* @param OutputInterface $output
* @return void
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$project = new Project(getcwd());
if ($project->isValid()) {
$releases = $project->getReleases($input->getOption('locale'));
if (count($releases)) {
$table = new Table($output);
$table->setHeaders(['Version']);
foreach ($releases as $release) {
$table->addRow([$release->getVersionNumber()]);
}
$table->render();
$output->writeln('');
if (count($releases) === 1) {
$output->writeln('1 release found');
} else {
$output->writeln(count($releases) . ' releases found');
}
} else {
$output->writeln('0 releases found');
}
} else {
$output->writeln('<error>This is not a valid Shade project</error>');
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$file = $input->getArgument("file");
$list = array_filter($this->filesystem->listContents($file, true), function ($file) {
return isset($file['type']) and ($file['type'] === "file" and isset($file['extension']) and $file['extension'] === "php");
});
// If the file argument is not directory, the listContents will return empty array.
// In this case the user has specified a file
if (empty($list)) {
$list = [["path" => $this->filesystem->get($file)->getPath()]];
}
$dump = array_map(function ($file) use($output) {
$output->writeln("Indexing " . $file['path'] . "...");
return Indexer::index($this->filesystem->get($file['path']));
}, $list);
$table = new Table($output);
$outputs = [];
foreach ($dump as $a) {
foreach ($a["functions"] as $val) {
$outputs[] = [$val['file']->getPath(), $val['function'], implode(", ", array_map(function ($param) {
return implode('|', $param['type']) . " " . $param['name'];
}, $val['arguments'])), implode(", ", $val['return']), (string) $val['scope']];
}
}
$output->writeln("Indexing complete!");
$output->writeln("Scanned " . count($list) . " files.");
$output->writeln("Detected " . count($outputs) . " functions.");
$output->writeln("Rendering Table...");
$table->setHeaders(['File', 'Function', 'Arguments', 'Return', 'Scope'])->setRows($outputs);
$table->render();
}
public function execute(InputInterface $input, OutputInterface $output)
{
$this->addStyles($output);
$suite = $input->getArgument('suite');
$config = $this->getSuiteConfig($suite, $input->getOption('config'));
$config['describe_steps'] = true;
$loader = new Gherkin($config);
$steps = $loader->getSteps();
foreach ($steps as $name => $context) {
/** @var $table Table **/
$table = new Table($output);
$table->setHeaders(array('Step', 'Implementation'));
$output->writeln("Steps from <bold>{$name}</bold> context:");
foreach ($context as $step => $callable) {
if (count($callable) < 2) {
continue;
}
$method = $callable[0] . '::' . $callable[1];
$table->addRow([$step, $method]);
}
$table->render();
}
if (!isset($table)) {
$output->writeln("No steps are defined, start creating them by running <bold>gherkin:snippets</bold>");
}
}
/**
* @param InputInterface $input
* @param OutputInterface $output
*
* @return int
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$channel = $input->getOption('channel');
$channelId = $input->getOption('id');
$key = $channel . $channelId;
if (!$this->checkRunStatus($input, $output, empty($key) ? 'all' : $key)) {
return 0;
}
$translator = $this->getContainer()->get('translator');
$translator->setLocale($this->getContainer()->get('mautic.helper.core_parameters')->getParameter('locale'));
$dispatcher = $this->getContainer()->get('event_dispatcher');
$event = $dispatcher->dispatch(CoreEvents::CHANNEL_BROADCAST, new ChannelBroadcastEvent($channel, $channelId, $output));
$results = $event->getResults();
$rows = [];
foreach ($results as $channel => $counts) {
$rows[] = [$channel, $counts['success'], $counts['failed']];
}
// Put a blank line after anything the event spits out
$output->writeln('');
$output->writeln('');
$table = new Table($output);
$table->setHeaders([$translator->trans('mautic.core.channel'), $translator->trans('mautic.core.channel.broadcast_success_count'), $translator->trans('mautic.core.channel.broadcast_failed_count')])->setRows($rows);
$table->render();
$this->completeRun();
return 0;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$language = $input->getArgument('language');
$table = new Table($output);
$table->setStyle('compact');
$this->displayUpdates($language, $output, $table);
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$reader = new AnnotationReader();
/** @var ManagerRegistry $doctrine */
$doctrine = $this->getContainer()->get('doctrine');
$em = $doctrine->getManager();
$cmf = $em->getMetadataFactory();
$existing = [];
$created = [];
/** @var ClassMetadata $metadata */
foreach ($cmf->getAllMetadata() as $metadata) {
$refl = $metadata->getReflectionClass();
if ($refl === null) {
$refl = new \ReflectionClass($metadata->getName());
}
if ($reader->getClassAnnotation($refl, 'Padam87\\AttributeBundle\\Annotation\\Entity') != null) {
$schema = $em->getRepository('Padam87AttributeBundle:Schema')->findOneBy(['className' => $metadata->getName()]);
if ($schema === null) {
$schema = new Schema();
$schema->setClassName($metadata->getName());
$em->persist($schema);
$em->flush($schema);
$created[] = $metadata->getName();
} else {
$existing[] = $metadata->getName();
}
}
}
$table = new Table($output);
$table->addRow(['Created:', implode(PHP_EOL, $created)]);
$table->addRow(new TableSeparator());
$table->addRow(['Existing:', implode(PHP_EOL, $existing)]);
$table->render();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$isVerbose = $output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE;
$projectCode = $input->getOption('project-code');
$enrollmentStatusCode = $input->getOption('enrollment-status-code');
$memberResource = new MemberResource($this->sourceClient);
$page = 0;
$perPage = 10;
$maxPages = 1;
$criteria = [];
if ($enrollmentStatusCode) {
$criteria['enrollment_status_code'] = $enrollmentStatusCode;
}
$data = [];
while ($page < $maxPages) {
$members = $memberResource->getList(++$page, $perPage, $criteria, [], [], ['project_code' => $projectCode]);
$maxPages = $members['pages'];
// if no items, return
if (!count($members['items']) || !$members['total']) {
break;
}
foreach ($members['items'] as $key => $member) {
if ($isVerbose) {
$no = ($page - 1) * $perPage + $key + 1;
// $output->writeln("{$no} - Reading member #{$member['id']}");
}
$data[] = ['code' => isset($member['code']) ? $member['code'] : '#' . $member['id'], 'email' => isset($member['email_within_project']) ? $member['email_within_project'] : '-', 'phone' => isset($member['phone_within_project']) ? $member['phone_within_project'] : '-', 'enrollment_status_code' => isset($member['enrollment_status_code']) ? $member['enrollment_status_code'] : '-'];
}
}
$table = new Table($output);
$table->setHeaders(['code', 'email', 'phone', 'enrollment_status_code'])->setRows($data);
$table->render();
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$missingOption = [];
$optionScopeCount = 1;
if (null === ($rainbowTablePath = $input->getOption("rainbow-table"))) {
$missingOption[] = "rainbow-table";
}
if ($optionScopeCount === count($missingOption)) {
throw MissingOptionException::create($missingOption);
}
$rainbowTable = new FileHandler($rainbowTablePath, FileHandlerInterface::MODE_READ_ONLY);
$mode = RainbowPHPInterface::LOOKUP_MODE_SIMPLE;
if ($input->getOption("partial")) {
$mode |= RainbowPHPInterface::LOOKUP_MODE_PARTIAL;
}
if ($input->getOption("deep-search")) {
$mode |= RainbowPHPInterface::LOOKUP_MODE_DEEP;
}
$hash = $input->getArgument("hash");
$foundHashes = $this->rainbow->lookupHash($rainbowTable, $hash, $mode);
if (empty($foundHashes)) {
$output->writeln(sprintf("No value found for the hash '%s'", $hash));
} else {
$tableHelper = new Table($output);
$tableHelper->setHeaders(["Hash", "Value"]);
foreach ($foundHashes as $value => $foundHash) {
$tableHelper->addRow([$foundHash, $value]);
}
$tableHelper->render();
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$client = $this->get('client');
$features = array();
if (!empty($input->getOption('features'))) {
$features = explode(',', $input->getOption('features'));
}
try {
$result = $client->api('clients')->getList($features);
$clients = array();
if ('ok' === strtolower($result['stat']) && !empty($result['results'])) {
$clients = $result['results'];
}
$rows = array();
foreach ($clients as $client) {
$rows[] = array($client['client_id'], $client['client_secret'], $client['description']);
}
$table = new Table($output);
$table->setHeaders(array('client_id', 'client_secret', 'description'))->setRows($rows);
$table->render();
exit(0);
} catch (\Exception $e) {
$output->writeln('<error>' . $e->getMessage() . '</error>');
exit(1);
}
}
/**
* @param OutputInterface $output
* @param string $action
*/
protected function dumpProcessors(OutputInterface $output, $action)
{
/** @var ProcessorBagInterface $processorBag */
$processorBag = $this->getContainer()->get('oro_api.processor_bag');
$table = new Table($output);
$table->setHeaders(['Processor', 'Attributes']);
$context = new Context();
$context->setAction($action);
$processors = $processorBag->getProcessors($context);
$processors->setApplicableChecker(new ChainApplicableChecker());
$i = 0;
foreach ($processors as $processor) {
if ($i > 0) {
$table->addRow(new TableSeparator());
}
$processorColumn = sprintf('<comment>%s</comment>%s%s', $processors->getProcessorId(), PHP_EOL, get_class($processor));
$processorDescription = $this->getClassDocComment(get_class($processor));
if (!empty($processorDescription)) {
$processorColumn .= PHP_EOL . $processorDescription;
}
$attributesColumn = $this->formatProcessorAttributes($processors->getProcessorAttributes());
$table->addRow([$processorColumn, $attributesColumn]);
$i++;
}
$table->render();
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$repository = $this->getRepository();
/** @var FilesystemInterface $master */
$master = $this->getContainer()->get('repository.master_storage');
/** @var CertificateParser $certificateParser */
$certificateParser = $this->getContainer()->get('ssl.certificate_parser');
$table = new Table($output);
$table->setHeaders(['Domain', 'Issuer', 'Valid from', 'Valid to', 'Needs renewal?']);
$directories = $master->listContents('certs');
foreach ($directories as $directory) {
if ($directory['type'] !== 'dir') {
continue;
}
$parsedCertificate = $certificateParser->parse($repository->loadDomainCertificate($directory['basename']));
$domainString = $parsedCertificate->getSubject();
$alternativeNames = array_diff($parsedCertificate->getSubjectAlternativeNames(), [$parsedCertificate->getSubject()]);
if (count($alternativeNames)) {
sort($alternativeNames);
$last = array_pop($alternativeNames);
foreach ($alternativeNames as $alternativeName) {
$domainString .= "\n ├── " . $alternativeName;
}
$domainString .= "\n └── " . $last;
}
$table->addRow([$domainString, $parsedCertificate->getIssuer(), $parsedCertificate->getValidFrom()->format('Y-m-d H:i:s'), $parsedCertificate->getValidTo()->format('Y-m-d H:i:s'), $parsedCertificate->getValidTo()->format('U') - time() < 604800 ? '<comment>Yes</comment>' : 'No']);
}
$table->render();
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$namespaces = $this->getContainer()->get('solr.doctrine.classnameresolver.known_entity_namespaces');
$metaInformationFactory = $this->getContainer()->get('solr.meta.information.factory');
foreach ($namespaces->getEntityClassnames() as $classname) {
try {
$metaInformation = $metaInformationFactory->loadInformation($classname);
} catch (\RuntimeException $e) {
$output->writeln(sprintf('<info>%s</info>', $e->getMessage()));
continue;
}
$output->writeln(sprintf('<comment>%s</comment>', $classname));
$output->writeln(sprintf('Documentname: %s', $metaInformation->getDocumentName()));
$output->writeln(sprintf('Document Boost: %s', $metaInformation->getBoost() ? $metaInformation->getBoost() : '-'));
$table = new Table($output);
$table->setHeaders(array('Property', 'Document Fieldname', 'Boost'));
foreach ($metaInformation->getFieldMapping() as $documentField => $property) {
$field = $metaInformation->getField($documentField);
if ($field === null) {
continue;
}
$table->addRow(array($property, $documentField, $field->boost));
}
$table->render();
}
}
/**
* This method is executed after initialize(). It usually contains the logic
* to execute to complete this command task.
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$maxResults = $input->getOption('max-results');
// Use ->findBy() instead of ->findAll() to allow result sorting and limiting
$users = $this->em->getRepository('AppBundle:User')->findBy(array(), array('id' => 'DESC'), $maxResults);
// Doctrine query returns an array of objects and we need an array of plain arrays
$usersAsPlainArrays = array_map(function ($user) {
return array($user->getId(), $user->getUsername(), $user->getEmail(), implode(', ', $user->getRoles()));
}, $users);
// In your console commands you should always use the regular output type,
// which outputs contents directly in the console window. However, this
// particular command uses the BufferedOutput type instead.
// The reason is that the table displaying the list of users can be sent
// via email if the '--send-to' option is provided. Instead of complicating
// things, the BufferedOutput allows to get the command output and store
// it in a variable before displaying it.
$bufferedOutput = new BufferedOutput();
$table = new Table($bufferedOutput);
$table->setHeaders(array('ID', 'Username', 'Email', 'Roles'))->setRows($usersAsPlainArrays);
$table->render();
// instead of displaying the table of users, store it in a variable
$tableContents = $bufferedOutput->fetch();
if (null !== ($email = $input->getOption('send-to'))) {
$this->sendReport($tableContents, $email);
}
$output->writeln($tableContents);
}
/**
* @param OutputInterface $output
* @param RuleInterface $rule
*/
private function printRule(OutputInterface $output, RuleInterface $rule)
{
$table = new Table($output);
$table->setStyle('compact')->setRows([['Name', $rule->getName()], ['Category', $rule->getCategory()], ['Severity', $rule->getSeverity()], ['Message', $rule->getMessage()]]);
$table->render();
$output->writeln('---------------------------------------------');
}
/**
* @param string $path
* @param InputInterface $input
* @param OutputInterface $output
*/
protected function binaryInstallWindows($path, InputInterface $input, OutputInterface $output)
{
$php = Engine::factory();
$table = new Table($output);
$table->setRows([['<info>' . $php->getName() . ' Path</info>', $php->getPath()], ['<info>' . $php->getName() . ' Version</info>', $php->getVersion()], ['<info>Compiler</info>', $php->getCompiler()], ['<info>Architecture</info>', $php->getArchitecture()], ['<info>Thread safety</info>', $php->getZts() ? 'yes' : 'no'], ['<info>Extension dir</info>', $php->getExtensionDir()], ['<info>php.ini</info>', $php->getIniPath()]])->render();
$inst = Install::factory($path);
$progress = $this->getHelperSet()->get('progress');
$inst->setProgress($progress);
$inst->setInput($input);
$inst->setOutput($output);
$inst->install();
$deps_handler = new Windows\DependencyLib($php);
$deps_handler->setProgress($progress);
$deps_handler->setInput($input);
$deps_handler->setOutput($output);
$helper = $this->getHelperSet()->get('question');
$cb = function ($choices) use($helper, $input, $output) {
$question = new ChoiceQuestion('Multiple choices found, please select the appropriate dependency package', $choices);
$question->setMultiselect(false);
return $helper->ask($input, $output, $question);
};
foreach ($inst->getExtDllPaths() as $dll) {
if (!$deps_handler->resolveForBin($dll, $cb)) {
throw new \Exception('Failed to resolve dependencies');
}
}
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$memcachedAddress = $input->getOption('address');
$memcachedPort = $input->getOption('port');
$memcachedHelper = new MemcachedHelper($memcachedAddress, $memcachedPort);
if ($input->getOption('count')) {
$keysCount = $memcachedHelper->getKeysCount();
$output->writeln("<info>Number of the keys in storage: {$keysCount}</info>");
return;
}
$keys = $input->getArgument('key');
$compactMode = !empty($keys) && count($keys) <= 3 ? true : false;
$keysNumber = $input->getOption('number');
$mcData = $memcachedHelper->getMemcacheData($keys, $keysNumber, $compactMode);
if ($compactMode && is_array($mcData) && !empty($mcData)) {
$outputStyle = new OutputFormatterStyle('yellow', null, array('bold'));
$output->getFormatter()->setStyle('compactInfo', $outputStyle);
foreach ($mcData as $data) {
$output->writeln("<compactInfo>Key:</compactInfo> {$data[0]}");
$output->writeln("");
$output->writeln("<compactInfo>Value:</compactInfo> {$data[1]}");
$output->writeln("");
$output->writeln("<fg=green;options=bold>------------------------------------------</>");
}
} elseif (is_array($mcData) && !empty($mcData)) {
$table = new Table($output);
$table->setHeaders(['Key', 'Value'])->setRows($mcData);
$table->render();
} else {
$output->writeln("<error>Nothing to show! Check your memcached server.</error>");
}
}
/**
* @param InputInterface $input
* @param OutputInterface $output
* @return void
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$project = new Project(getcwd());
if ($project->isValid()) {
$videos = $project->getVideos($input->getOption('locale'));
if ($videos->count()) {
$table = new Table($output);
$table->setHeaders(['Name', 'Group', 'Title', 'Play Time', 'Wistia Code']);
foreach ($videos as $video) {
$table->addRow([$video->getShortName(), $video->getGroupName(), $video->getTitle(), $video->getPlayTime(), $video->getProperty('wistia_code')]);
}
$table->render();
$output->writeln('');
if ($videos->count() === 1) {
$output->writeln('1 video found');
} else {
$output->writeln($videos->count() . ' videos found');
}
} else {
$output->writeln('0 videos found');
}
} else {
$output->writeln('<error>This is not a valid Shade project</error>');
}
}
/**
* Execute the command.
*
* @param \Symfony\Component\Console\Input\InputInterface $input
* @param \Symfony\Component\Console\Output\OutputInterface $output
* @return void
*/
public function execute(InputInterface $input, OutputInterface $output)
{
$client = new Client();
$modname = $input->getArgument('modname');
$modversion = $input->getArgument('modversion');
$config = solder_config();
$response = $client->get($config->api);
$server = $response->json();
$response = $client->get($config->api . '/mod/' . $modname . '/' . $modversion);
$json = $response->json();
if (isset($json['error'])) {
throw new \Exception($json['error']);
}
$rows = array();
foreach ($json as $key => $value) {
if ($key == 'versions') {
$rows[] = array("<info>{$key}</info>", implode($value, "\n"));
} else {
$rows[] = array("<info>{$key}</info>", mb_strimwidth($value, 0, 80, "..."));
}
}
$output->writeln('<comment>Server:</comment>');
$output->writeln(" <info>{$server['api']}</info> version {$server['version']}");
$output->writeln(" {$api}");
$output->writeln('');
$output->writeln("<comment>Mod:</comment>");
$table = new Table($output);
$table->setRows($rows)->setStyle('compact')->render();
}
/**
* Executes the current command.
*
* This method is not abstract because you can use this class
* as a concrete class. In this case, instead of defining the
* execute() method, you set the code to execute by passing
* a Closure to the setCode() method.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*
* @return null|int null or 0 if everything went fine, or an error code
*
* @throws \LogicException When this abstract method is not implemented
*
* @see setCode()
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
/** @var DefinitionChecker $checker */
$checker = $this->getContainer()->get('babymarkt_ext_cron.service.definitionchecker');
$checker->setApplication($this->getApplication());
/** @var Definition[] $definitions */
$definitions = $this->getContainer()->getParameter('babymarkt_ext_cron.definitions');
$errorFound = false;
if (count($definitions)) {
$resultList = [];
foreach ($definitions as $alias => $definition) {
$definition = new Definition($definition);
if ($definition->isDisabled()) {
$resultList[] = ['alias' => $alias, 'command' => $definition->getCommand(), 'result' => '<comment>Disabled</comment>'];
} else {
if (!$checker->check($definition)) {
$resultList[] = ['alias' => $alias, 'command' => $definition->getCommand(), 'result' => '<error>' . $checker->getResult() . '</error>'];
$errorFound = true;
} else {
$resultList[] = ['alias' => $alias, 'command' => $definition->getCommand(), 'result' => '<info>OK</info>'];
}
}
}
$table = new Table($output);
$table->setHeaders(['Alias', 'Command', 'Result']);
$table->setRows($resultList);
$table->render();
} else {
$output->writeln('<comment>No cron job definitions found.</comment>');
}
return (int) $errorFound;
}
/**
* Execute command
*
* @param InputInterface $input
* @param OutputInterface $output
*
* @return void
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$techHeader = new TechHeader();
$techHeader->setRequest($this->request);
$values = $techHeader->getHeaders($this->url);
if (empty($values)) {
if ($input->getOption('json')) {
$this->output->write(json_encode(['error' => 'No detectable technology was found']));
} else {
$this->output->writeln('No detectable technology was found');
}
return;
}
if ($input->getOption('json')) {
$this->output->write(json_encode($values));
} else {
$rows = array();
foreach ($values as $key => $value) {
$rows[] = array($key, $value);
}
$this->writeHeader('Server Technology');
$table = new Table($this->output);
$table->setHeaders(array('Key', 'Value'))->setRows($rows)->render();
}
}
public function execute(InputInterface $input, OutputInterface $output)
{
$source = $input->getArgument('source');
if (is_dir($source) === false && is_file($source) === false) {
throw new \InvalidArgumentException(sprintf('"%s" is not a file or a directory', $source));
}
$logger = new Logger($this->output, $input->getOption('debug'));
if (is_dir($source) === true) {
$collector = new DirectoryCodeCollector(array($source));
} elseif (is_file($source) === true) {
$collector = new FileCodeCollector(array($source));
}
foreach ($this->engine->convert($collector, $logger, $input->getArgument('file')) as $file) {
$this->fileRender->render($file);
}
$table = new Table($this->output);
$table->setHeaders(array(array(new TableCell('Incompatibility', array('colspan' => 4))), array('Type', 'Message', 'Line', 'Class')));
$table->setRows($logger->getIncompatibility());
$table->render();
if ($input->getOption('v') === true) {
$table = new Table($this->output);
$table->setHeaders(array(array(new TableCell('Log', array('colspan' => 3))), array('Message', 'Line', 'Class')));
$table->setRows($logger->getLogs());
$table->render();
}
}
private function printTable(array $headers, array $rows, OutputInterface $output)
{
$table = new Table($output);
$table->setHeaders($headers);
$table->setRows($rows);
$table->render();
}
/**
* @param InputInterface $input
* @param OutputInterface $output
* @return void
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$project = new Project(getcwd());
if ($project->isValid()) {
$common_questions = $project->getCommonQuestions($input->getOption('locale'));
if (count($common_questions)) {
$table = new Table($output);
$table->setHeaders(['Question', 'Book', 'Page', 'Position']);
foreach ($common_questions as $common_question) {
$table->addRow([$common_question['question'], $common_question['book'], $common_question['page'], $common_question['position']]);
}
$table->render();
$output->writeln('');
if (count($common_questions) === 1) {
$output->writeln('1 question found');
} else {
$output->writeln(count($common_questions) . ' questions found');
}
} else {
$output->writeln('0 questions found');
}
} else {
$output->writeln('<error>This is not a valid Shade project</error>');
}
}