Console Commands

// In lib/console/my_command.php

use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Output\OutputInterface;

class rex_command_my_custom extends rex_console_command
{
    protected function configure(): void
    {
        $this
            ->setDescription('Does something custom')
            ->addArgument('name', InputArgument::REQUIRED, 'Name parameter')
            ->addOption('force', 'f', InputOption::VALUE_NONE, 'Force execution');
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        $name = $input->getArgument('name');
        $force = $input->getOption('force');
        
        // Logik
        if (!$force && !$this->confirm('Really proceed?')) {
            $io->warning('Aborted');
            return 1;
        }
        
        // Verarbeitung
        $io->success('Successfully processed: ' . $name);
        
        return 0; // 0 = success, 1+ = error
    }
}

// In boot.php eines Addons

if (rex::isConsole()) {
    rex_console::addCommand('myAddon:import', new rex_command_my_import());
    rex_console::addCommand('myAddon:export', new rex_command_my_export());
    rex_console::addCommand('myAddon:sync', new rex_command_my_sync());
}

// Verwendung
// php bin/console myAddon:import data.json
// php bin/console myAddon:export output.json

class rex_command_example extends rex_console_command
{
    protected function configure(): void
    {
        $this
            ->setDescription('Example command')
            // Required Argument
            ->addArgument('file', InputArgument::REQUIRED, 'File path')
            // Optional Argument
            ->addArgument('output', InputArgument::OPTIONAL, 'Output file', 'default.txt')
            // Array Argument (mehrere Werte)
            ->addArgument('ids', InputArgument::IS_ARRAY, 'Multiple IDs')
            
            // Boolean Option (Flag)
            ->addOption('force', 'f', InputOption::VALUE_NONE, 'Force')
            // Option mit Wert
            ->addOption('format', null, InputOption::VALUE_REQUIRED, 'Format', 'json')
            // Option mit optionalem Wert
            ->addOption('verbose', 'v', InputOption::VALUE_OPTIONAL, 'Verbose level', 1);
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        // Arguments
        $file = $input->getArgument('file');
        $outputFile = $input->getArgument('output');
        $ids = $input->getArgument('ids'); // Array
        
        // Options
        $force = $input->getOption('force'); // bool
        $format = $input->getOption('format'); // string
        $verbose = $input->getOption('verbose'); // int|null
        
        $io->success('Done');
        return 0;
    }
}

// Aufruf:
// php bin/console example input.json output.json 1 2 3 --force --format=xml -v

class rex_command_interactive extends rex_console_command
{
    protected function configure(): void
    {
        $this->setDescription('Interactive command');
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        // Frage stellen
        $name = $io->ask('What is your name?', 'default');
        
        // Passwort abfragen (hidden)
        $password = $io->askHidden('Enter password');
        
        // Ja/Nein-Frage
        if ($io->confirm('Continue?', true)) {
            // ...
        }
        
        // Auswahl (Choice)
        $format = $io->choice('Select format', ['json', 'xml', 'csv'], 'json');
        
        // Ausgabe
        $io->title('My Command');
        $io->section('Processing');
        $io->text('Some text');
        $io->success('Success message');
        $io->error('Error message');
        $io->warning('Warning message');
        $io->note('Note message');
        $io->caution('Caution message');
        
        // Tabelle
        $io->table(
            ['ID', 'Name', 'Status'],
            [
                [1, 'Item 1', 'Active'],
                [2, 'Item 2', 'Inactive'],
            ]
        );
        
        // Progress Bar
        $io->progressStart(100);
        for ($i = 0; $i < 100; $i++) {
            $io->progressAdvance();
            usleep(10000);
        }
        $io->progressFinish();
        
        return 0;
    }
}

class rex_command_safe extends rex_console_command
{
    protected function configure(): void
    {
        $this->setDescription('Safe command');
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        try {
            // Risikante Operation
            $this->doSomethingRisky();
            
            $io->success('Success');
            return 0;
            
        } catch (Exception $e) {
            // Fehler ausgeben
            $io->error($e->getMessage());
            
            // Optional: Stack Trace
            if ($input->getOption('verbose')) {
                $io->text($e->getTraceAsString());
            }
            
            return 1; // Error-Code
        }
    }
}

class rex_command_validate extends rex_console_command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        $file = $input->getArgument('file');
        
        // File existiert?
        if (!file_exists($file)) {
            throw new InvalidArgumentException('File not found: ' . $file);
        }
        
        // Format korrekt?
        $format = $input->getOption('format');
        if (!in_array($format, ['json', 'xml', 'csv'])) {
            throw new InvalidArgumentException('Invalid format: ' . $format);
        }
        
        $io->success('Validation passed');
        return 0;
    }
}

class rex_command_i18n extends rex_console_command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        // rex_i18n liefert HTML (z.B. <br>)
        $message = rex_i18n::msg('my_message');
        // Output: "Line 1<br />Line 2"
        
        // Für CLI dekodieren
        $cliMessage = $this->decodeMessage($message);
        // Output: "Line 1\nLine 2"
        
        $io->text($cliMessage);
        
        return 0;
    }
}

// Command mit Package-Kontext
class myAddon_command extends rex_console_command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        // Package abrufen
        $package = $this->getPackage();
        
        if ($package) {
            $io->text('Package: ' . $package->getPackageId());
            $io->text('Version: ' . $package->getVersion());
            $io->text('Path: ' . $package->getPath());
        }
        
        return 0;
    }
}

// Registrierung mit Package
if (rex::isConsole()) {
    $addon = rex_addon::get('myAddon');
    $command = new myAddon_command();
    $command->setPackage($addon);
    rex_console::addCommand('myAddon:info', $command);
}

// In tests/console_test.php

use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;

class ConsoleTest extends PHPUnit\Framework\TestCase
{
    public function testCacheClear()
    {
        $application = new Application();
        $application->add(new rex_command_cache_clear());
        
        $command = $application->find('cache:clear');
        $tester = new CommandTester($command);
        $tester->execute([]);
        
        $output = $tester->getDisplay();
        $this->assertStringContainsString('erfolgreich', $output);
        $this->assertEquals(0, $tester->getStatusCode());
    }
}

class rex_command_multi_step extends rex_console_command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        
        $io->title('Multi-Step Process');
        
        // Step 1
        $io->section('Step 1: Validation');
        if (!$this->validate()) {
            $io->error('Validation failed');
            return 1;
        }
        $io->success('Validation passed');
        
        // Step 2
        $io->section('Step 2: Processing');
        $io->progressStart(100);
        for ($i = 0; $i < 100; $i++) {
            $this->process($i);
            $io->progressAdvance();
        }
        $io->progressFinish();
        
        // Step 3
        $io->section('Step 3: Cleanup');
        $this->cleanup();
        $io->success('Cleanup done');
        
        $io->success('All steps completed successfully');
        return 0;
    }
}

class rex_command_logged extends rex_console_command
{
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        $logger = rex_logger::factory();
        
        $logger->info('Command started', ['command' => $this->getName()]);
        
        try {
            // Verarbeitung
            $result = $this->doSomething();
            
            $logger->info('Command completed', ['result' => $result]);
            $io->success('Done');
            return 0;
            
        } catch (Exception $e) {
            $logger->error('Command failed', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);
            
            $io->error($e->getMessage());
            return 1;
        }
    }
}

class rex_command_silent extends rex_console_command
{
    protected function configure(): void
    {
        $this
            ->setDescription('Silent command')
            ->addOption('quiet', 'q', InputOption::VALUE_NONE, 'No output');
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        $quiet = $input->getOption('quiet');
        
        // Verarbeitung
        $result = $this->process();
        
        if (!$quiet) {
            $io->success('Processed: ' . $result);
        }
        
        return 0;
    }
}

// Aufruf:
// php bin/console silent:command --quiet

class rex_command_dryrun extends rex_console_command
{
    protected function configure(): void
    {
        $this
            ->setDescription('Command with dry-run')
            ->addOption('dry-run', null, InputOption::VALUE_NONE, 'Simulate without changes');
    }
    
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = $this->getStyle($input, $output);
        $dryRun = $input->getOption('dry-run');
        
        if ($dryRun) {
            $io->note('DRY-RUN MODE - No changes will be made');
        }
        
        $items = $this->getItems();
        
        foreach ($items as $item) {
            if ($dryRun) {
                $io->text('Would delete: ' . $item);
            } else {
                $this->delete($item);
                $io->text('Deleted: ' . $item);
            }
        }
        
        $io->success($dryRun ? 'Dry-run completed' : 'Completed');
        return 0;
    }
}