generated from Nodarx/template
362 lines
13 KiB
PHP
362 lines
13 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/**
|
|
* SPDX-FileCopyrightText: Sebastian Krupinski <krupinski01@gmail.com>
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*/
|
|
|
|
namespace KTXM\ProviderImap\Console;
|
|
|
|
use KTXC\SessionTenant;
|
|
use KTXM\ProviderImap\Client\Command\SelectCommand;
|
|
use KTXM\ProviderImap\Client\FetchOptions;
|
|
use KTXM\ProviderImap\Client\FetchTarget;
|
|
use KTXM\ProviderImap\Client\Message;
|
|
use KTXM\ProviderImap\Client\SequenceSet;
|
|
use KTXM\ProviderImap\Providers\Provider;
|
|
use KTXM\ProviderImap\Providers\Service;
|
|
use KTXM\ProviderImap\Service\Remote\RemoteService;
|
|
use Symfony\Component\Console\Attribute\AsCommand;
|
|
use Symfony\Component\Console\Command\Command;
|
|
use Symfony\Component\Console\Input\InputArgument;
|
|
use Symfony\Component\Console\Input\InputInterface;
|
|
use Symfony\Component\Console\Input\InputOption;
|
|
use Symfony\Component\Console\Output\OutputInterface;
|
|
use Symfony\Component\Console\Style\SymfonyStyle;
|
|
|
|
/**
|
|
* Live IMAP service diagnostic.
|
|
*
|
|
* Loads an existing stored IMAP service, connects with its saved credentials,
|
|
* shows a bounded list of mailboxes, then prints the most recent messages
|
|
* from a selected mailbox.
|
|
*/
|
|
#[AsCommand(
|
|
name: 'provider_imap_mail:service:test',
|
|
description: 'Test an existing IMAP service and inspect mailboxes and messages',
|
|
)]
|
|
class TestCommand extends Command
|
|
{
|
|
public function __construct(
|
|
private readonly Provider $provider,
|
|
private readonly SessionTenant $sessionTenant,
|
|
) {
|
|
parent::__construct();
|
|
}
|
|
|
|
protected function configure(): void
|
|
{
|
|
$this
|
|
->addArgument('service-id', InputArgument::OPTIONAL, 'Stored service ID to test')
|
|
->addOption('tenant', 't', InputOption::VALUE_REQUIRED, 'Tenant ID')
|
|
->addOption('user', 'u', InputOption::VALUE_REQUIRED, 'User ID')
|
|
->addOption('mailbox', 'm', InputOption::VALUE_REQUIRED, 'Specific mailbox to inspect (for example: INBOX)')
|
|
->addOption('mailbox-limit', null, InputOption::VALUE_REQUIRED, 'Maximum number of mailboxes to inspect (default: 5, 0 = all)', '5')
|
|
->addOption('message-limit', null, InputOption::VALUE_REQUIRED, 'Maximum number of recent messages to show (default: 5, 0 = none)', '5')
|
|
->setHelp(<<<'HELP'
|
|
The <info>provider_imap_mail:service:test</info> command performs a live
|
|
diagnostic against an already stored IMAP service.
|
|
|
|
It will:
|
|
1. Load the saved service for a tenant/user pair
|
|
2. Connect and authenticate with the stored credentials
|
|
3. Show a bounded list of selectable mailboxes
|
|
4. Show the most recent messages from the selected mailbox
|
|
|
|
Examples:
|
|
|
|
Interactive service selection:
|
|
<info>provider_imap_mail:service:test --tenant=t1 --user=u1</info>
|
|
|
|
Test a specific stored service:
|
|
<info>provider_imap_mail:service:test abc123 --tenant=t1 --user=u1</info>
|
|
|
|
Show recent messages from INBOX:
|
|
<info>provider_imap_mail:service:test abc123 --tenant=t1 --user=u1 --mailbox=INBOX</info>
|
|
|
|
Show 10 mailboxes and 3 recent messages from Drafts:
|
|
<info>provider_imap_mail:service:test abc123 --tenant=t1 --user=u1 --mailbox=Drafts --mailbox-limit=10 --message-limit=3</info>
|
|
HELP);
|
|
}
|
|
|
|
protected function execute(InputInterface $input, OutputInterface $output): int
|
|
{
|
|
$io = new SymfonyStyle($input, $output);
|
|
|
|
$tenantId = (string) ($input->getOption('tenant') ?? '');
|
|
$userId = (string) ($input->getOption('user') ?? '');
|
|
$serviceId = (string) ($input->getArgument('service-id') ?? '');
|
|
$mailboxName = trim((string) ($input->getOption('mailbox') ?? 'INBOX'));
|
|
$mailboxLimit = $this->normalizeLimit($input->getOption('mailbox-limit'), 5);
|
|
$messageLimit = $this->normalizeLimit($input->getOption('message-limit'), 5);
|
|
|
|
$errors = [];
|
|
if ($tenantId === '') {
|
|
$errors[] = 'Tenant ID is required (--tenant).';
|
|
}
|
|
if ($userId === '') {
|
|
$errors[] = 'User ID is required (--user).';
|
|
}
|
|
if ($serviceId === '') {
|
|
$errors[] = 'Service ID is required.';
|
|
}
|
|
|
|
if ($errors !== []) {
|
|
$io->error($errors);
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$this->sessionTenant->configureById($tenantId);
|
|
$service = $this->provider->serviceFetch($tenantId, $userId, $serviceId);
|
|
|
|
if ($service === null) {
|
|
$io->error(sprintf("Service '%s' not found.", $serviceId));
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$startedAt = microtime(true);
|
|
|
|
try {
|
|
$client = RemoteService::freshClient($service);
|
|
$mailService = RemoteService::mailService($service, $client);
|
|
$mailboxes = $mailService->collectionList();
|
|
} catch (\Throwable $e) {
|
|
$io->error('IMAP diagnostic failed: ' . $e->getMessage());
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$mailboxNames = array_keys($mailboxes);
|
|
sort($mailboxNames);
|
|
|
|
if (!in_array($mailboxName, $mailboxNames, true)) {
|
|
$io->error(sprintf("Mailbox '%s' not found on this service.", $mailboxName));
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$visibleMailboxNames = $mailboxLimit === 0
|
|
? $mailboxNames
|
|
: array_slice($mailboxNames, 0, $mailboxLimit);
|
|
|
|
$io->section('Service');
|
|
$io->definitionList(
|
|
['ID' => $serviceId],
|
|
['Label' => $service->getLabel() ?? $serviceId],
|
|
['Target' => $this->formatTarget($service)],
|
|
['Username' => $service->getIdentity()?->getIdentity() ?? '-'],
|
|
['Mailbox target' => $mailboxName],
|
|
['Mailbox list size' => $mailboxLimit === 0 ? 'all' : (string) $mailboxLimit],
|
|
['Recent message count' => (string) $messageLimit],
|
|
);
|
|
|
|
if ($mailboxNames === []) {
|
|
$io->warning('Authenticated successfully, but no selectable mailboxes were returned.');
|
|
return Command::SUCCESS;
|
|
}
|
|
|
|
$io->section('Mailboxes');
|
|
$mailboxRows = [];
|
|
foreach ($visibleMailboxNames as $name) {
|
|
$mailbox = $mailboxes[$name];
|
|
$properties = $mailbox->getProperties()->jsonSerialize();
|
|
$mailboxRows[] = [
|
|
$name,
|
|
(string) ($properties['role'] ?? 'custom'),
|
|
(string) ($mailbox->collection() ?? '-'),
|
|
(string) ($properties['delimiter'] ?? '/'),
|
|
$this->formatMailboxAttributes($properties['attributes'] ?? []),
|
|
];
|
|
}
|
|
|
|
$io->table(
|
|
['Mailbox', 'Role', 'Parent', 'Delimiter', 'Attributes'],
|
|
$mailboxRows,
|
|
);
|
|
|
|
if ($mailboxLimit !== 0 && count($visibleMailboxNames) < count($mailboxNames)) {
|
|
$io->note(sprintf(
|
|
'Mailbox list truncated to the first %d selectable mailboxes. Increase --mailbox-limit or set it to 0 to inspect all mailboxes.',
|
|
count($visibleMailboxNames),
|
|
));
|
|
}
|
|
|
|
$io->section(sprintf('Recent Messages: %s', $mailboxName));
|
|
|
|
try {
|
|
$mailboxClient = RemoteService::freshClient($service);
|
|
$mailboxService = RemoteService::mailService($service, $mailboxClient);
|
|
$selectedMailbox = $mailboxClient->perform(new SelectCommand($mailboxName, true));
|
|
} catch (\Throwable $e) {
|
|
$io->error('Mailbox inspection failed: ' . $e->getMessage());
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$totalMessages = $selectedMailbox->messages();
|
|
$io->text(sprintf('Total messages: <info>%d</info>', $totalMessages));
|
|
|
|
if ($totalMessages === 0) {
|
|
$io->note('No messages found in this mailbox.');
|
|
return Command::SUCCESS;
|
|
}
|
|
|
|
if ($messageLimit === 0) {
|
|
return Command::SUCCESS;
|
|
}
|
|
|
|
$sampleCount = min($totalMessages, $messageLimit);
|
|
$startSequence = max(1, $totalMessages - $sampleCount + 1);
|
|
$messageRows = [];
|
|
|
|
try {
|
|
foreach ($mailboxService->messageList(
|
|
$mailboxName,
|
|
FetchTarget::sequence(SequenceSet::range($startSequence, $totalMessages)),
|
|
FetchOptions::message(),
|
|
) as $message) {
|
|
$messageRows[] = [
|
|
(string) $message->uid(),
|
|
$this->formatSubject($message),
|
|
$this->formatSender($message),
|
|
$message->internalDate() ?? '-',
|
|
$this->formatFlags($message),
|
|
$this->formatBytes($message->size()),
|
|
];
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$io->error('Message listing failed: ' . $e->getMessage());
|
|
return Command::FAILURE;
|
|
}
|
|
|
|
$messageRows = array_reverse($messageRows);
|
|
|
|
$io->table(
|
|
['UID', 'Subject', 'From', 'Date', 'Flags', 'Size'],
|
|
$messageRows,
|
|
);
|
|
|
|
$elapsed = (int) round((microtime(true) - $startedAt) * 1000);
|
|
$io->text(sprintf('Elapsed: <info>%d ms</info>', $elapsed));
|
|
|
|
return Command::SUCCESS;
|
|
}
|
|
|
|
protected function interact(InputInterface $input, OutputInterface $output): void
|
|
{
|
|
$io = new SymfonyStyle($input, $output);
|
|
$io->title('IMAP Service Diagnostic');
|
|
|
|
if (!$input->getOption('tenant')) {
|
|
$tenant = $io->ask('Tenant ID');
|
|
if ($tenant) {
|
|
$input->setOption('tenant', $tenant);
|
|
}
|
|
}
|
|
|
|
if (!$input->getOption('user')) {
|
|
$user = $io->ask('User ID');
|
|
if ($user) {
|
|
$input->setOption('user', $user);
|
|
}
|
|
}
|
|
|
|
if ($input->getArgument('service-id')) {
|
|
return;
|
|
}
|
|
|
|
$tenantId = (string) ($input->getOption('tenant') ?? '');
|
|
$userId = (string) ($input->getOption('user') ?? '');
|
|
|
|
if ($tenantId === '' || $userId === '') {
|
|
return;
|
|
}
|
|
|
|
$this->sessionTenant->configureById($tenantId);
|
|
$services = $this->provider->serviceList($tenantId, $userId);
|
|
|
|
if ($services === []) {
|
|
return;
|
|
}
|
|
|
|
$choices = [];
|
|
foreach ($services as $id => $service) {
|
|
$label = $service->getLabel() ?? (string) $id;
|
|
$choices[$id] = sprintf('%s [%s] %s', $label, $id, $this->formatTarget($service));
|
|
}
|
|
|
|
$chosen = $io->choice('Select service to test', array_values($choices));
|
|
$serviceId = (string) array_search($chosen, $choices, true);
|
|
if ($serviceId !== '') {
|
|
$input->setArgument('service-id', $serviceId);
|
|
}
|
|
}
|
|
|
|
private function normalizeLimit(mixed $value, int $default): int
|
|
{
|
|
if ($value === null || $value === '') {
|
|
return $default;
|
|
}
|
|
|
|
$limit = (int) $value;
|
|
return $limit >= 0 ? $limit : $default;
|
|
}
|
|
|
|
private function formatTarget(Service $service): string
|
|
{
|
|
$location = $service->getLocation();
|
|
if ($location === null) {
|
|
return 'unknown';
|
|
}
|
|
|
|
return sprintf('%s://%s:%d', $location->getEncryption(), $location->getHost(), $location->getPort());
|
|
}
|
|
|
|
private function formatSender(Message $message): string
|
|
{
|
|
$sender = $message->from()[0] ?? $message->sender()[0] ?? null;
|
|
if ($sender === null) {
|
|
return '-';
|
|
}
|
|
|
|
return $sender->name() ?: ($sender->email() ?? '-');
|
|
}
|
|
|
|
private function formatSubject(Message $message): string
|
|
{
|
|
$subject = trim((string) ($message->subject() ?? ''));
|
|
if ($subject === '') {
|
|
return '(no subject)';
|
|
}
|
|
|
|
return mb_strimwidth($subject, 0, 60, '...');
|
|
}
|
|
|
|
private function formatFlags(Message $message): string
|
|
{
|
|
$flags = $message->flags();
|
|
return $flags === [] ? '-' : implode(', ', $flags);
|
|
}
|
|
|
|
private function formatMailboxAttributes(array $attributes): string
|
|
{
|
|
if ($attributes === []) {
|
|
return '-';
|
|
}
|
|
|
|
return implode(', ', $attributes);
|
|
}
|
|
|
|
private function formatBytes(int $bytes): string
|
|
{
|
|
$units = ['B', 'KB', 'MB', 'GB', 'TB'];
|
|
$size = (float) max(0, $bytes);
|
|
$unitIndex = 0;
|
|
|
|
while ($size >= 1024 && $unitIndex < count($units) - 1) {
|
|
$size /= 1024;
|
|
$unitIndex++;
|
|
}
|
|
|
|
return sprintf($unitIndex === 0 ? '%.0f %s' : '%.1f %s', $size, $units[$unitIndex]);
|
|
}
|
|
} |