fix(NextCloud members and script - part 1)

.env.example

@@ -68,16 +68,27 @@ DOLIBARR_URL=
 LIBARR_USERNAME=
 DOLIBARR_PWD=
 
-MAIL_ISPAPI_URL=
-MAIL_ISPAPI_USERNAME=
-MAIL_ISPAPI_PWD=
+# ISPConfig Mail Server
+ISPCONFIG_MAIL_SOAP_LOCATION=
+ISPCONFIG_MAIL_SOAP_URI=
+ISPCONFIG_MAIL_USERNAME=
+ISPCONFIG_MAIL_PASSWORD=
 
-HOSTING_ISPAPI_URL=
-HOSTING_ISPAPI_USERNAME=
-HOSTING_ISPAPI_PWD=
+# ISPConfig Web Server
+ISPCONFIG_WEB_SOAP_LOCATION=
+ISPCONFIG_WEB_SOAP_URI=
+ISPCONFIG_WEB_USERNAME=
+ISPCONFIG_WEB_PASSWORD=
 
-#NEXTCLOUD_API_ID=
-#NEXCLOUD_API_PWD=
+# ISPConfig Test server
+ISPCONFIG_TEST_SOAP_LOCATION=
+ISPCONFIG_TEST_SOAP_URI=
+ISPCONFIG_TEST_USERNAME=
+ISPCONFIG_TEST_PASSWORD=
+
+NEXTCLOUD_URL=
+NEXTCLOUD_USERNAME=
+NEXTCLOUD_PASSWORD=
 
 #SYMPA_API_ID=
 #SYMPA_API_PWD=

app/Console/Commands/HandleExpiredMembersDolibarr.php

@@ -0,0 +1,172 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Services\Dolibarr\DolibarrService;
+use App\Services\ISPConfig\ISPConfigMailService;
+use App\Services\Nextcloud\NextcloudService;
+use Illuminate\Console\Command;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Log;
+use Symfony\Component\Console\Command\Command as CommandAlias;
+
+class HandleExpiredMembersDolibarr extends Command
+{
+    protected $signature = 'members:cleanup-expired
+        {email? : Adresse email d\'un adhérent à traiter uniquement}
+        {--dry-run}';
+
+    public function __construct(
+        protected DolibarrService      $dolibarr,
+        protected ISPConfigMailService $mailService,
+        protected NextcloudService     $nextcloud
+    )
+    {
+        parent::__construct();
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function handle(): int
+    {
+        $dryRun = $this->option('dry-run');
+        $emailFilter = $this->argument('email');
+
+        $this->info(
+            $dryRun
+                ? 'DRY-RUN activé – aucune modification ne sera effectuée'
+                : 'Mode réel activé'
+        );
+
+        if ($emailFilter) {
+            $this->warn("Mode utilisateur unique : {$emailFilter}");
+        }
+
+        $this->info('Récupération des adhérents Dolibarr');
+
+        $members = collect($this->dolibarr->getAllMembers());
+        $today = now()->startOfDay();
+
+        $expiredMembers = $members->filter(function ($member) use ($today) {
+            if (($member['statut'] ?? null) != 1) {
+                return false;
+            }
+
+            if (empty($member['datefin'])) {
+                return false;
+            }
+
+            return \Carbon\Carbon::parse($member['datefin'])->lt($today);
+        });
+
+        if ($emailFilter) {
+            $expiredMembers = $expiredMembers->filter(function ($member) use ($emailFilter) {
+                return $this->extractRetzienEmail($member['email'] ?? null) === $emailFilter;
+            });
+
+            if ($expiredMembers->isEmpty()) {
+                $this->warn("Aucun adhérent expiré trouvé pour {$emailFilter}");
+                return CommandAlias::SUCCESS;
+            }
+        }
+
+        $this->info("{$expiredMembers->count()} adhérent(s) expiré(s)");
+
+        foreach ($expiredMembers as $member) {
+            try {
+                $this->processMember($member, $dryRun);
+            } catch (\Throwable $e) {
+                Log::error('Erreur traitement adhérent', [
+                    'member_id' => $member['id'],
+                    'error' => $e->getMessage(),
+                ]);
+            }
+        }
+
+        $this->info(
+            $dryRun
+                ? 'DRY-RUN terminé – aucune action effectuée'
+                : 'Traitement terminé'
+        );
+
+        return CommandAlias::SUCCESS;
+    }
+
+    /**
+     * @throws ConnectionException
+     * @throws \Exception
+     */
+    protected function processMember(array $member, bool $dryRun): void
+    {
+        $email = $this->extractRetzienEmail($member['email'] ?? null);
+
+        $this->line("• {$member['id']} - {$email}");
+
+        // Résiliation Dolibarr
+        if ($dryRun) {
+            $this->info("[DRY-RUN] Résiliation Dolibarr");
+        } else {
+            $this->dolibarr->updateMember($member['id'], [
+                'statut' => 0,
+            ]);
+        }
+
+        // Désactivation mail
+        if ($email) {
+            $this->disableMailAccount($email, $dryRun);
+        }
+
+        // Désactivation Nextcloud
+        if ($email) {
+            if ($dryRun) {
+                $this->info("[DRY-RUN] Désactivation Nextcloud");
+            } else {
+                $this->nextcloud->disableUserByEmail($email);
+            }
+        }
+    }
+
+    /**
+     * @throws \Exception
+     */
+    protected function disableMailAccount(string $email, bool $dryRun): void
+    {
+        $details = $this->mailService->getMailUserDetails($email);
+
+        if (!$details) {
+            $this->warn("Boîte mail inexistante : {$email}");
+            return;
+        }
+
+        if ($dryRun) {
+            $this->info("[DRY-RUN] Mail désactivé ({$email})");
+            return;
+        }
+
+        $result = $this->mailService->updateMailUser($email, [
+            'postfix' => 'n',
+            'disablesmtp' => 'y',
+            'disableimap' => 'y',
+            'disablepop3' => 'y',
+        ]);
+
+        if (!$result) {
+            throw new \RuntimeException("Échec désactivation mail ISPConfig pour {$email}");
+        }
+
+        $this->info("Mail désactivé : {$email}");
+    }
+
+    protected function extractRetzienEmail(?string $emails): ?string
+    {
+        if (!$emails) {
+            return null;
+        }
+
+        return collect(explode(';', $emails))
+            ->map(fn(string $email): string => trim($email))
+            ->filter(fn(string $email): bool => str_contains($email, '@retzien.fr'))
+            ->first();
+    }
+}

app/Console/Commands/SyncDolibarrMembers.php

@@ -4,7 +4,7 @@ namespace App\Console\Commands;
 
 use App\Models\Member;
 use App\Models\Membership;
-use App\Services\DolibarrService;
+use App\Services\Dolibarr\DolibarrService;
 use Carbon\Carbon;
 use Illuminate\Console\Command;
 use Illuminate\Http\Client\ConnectionException;

app/Console/Commands/SyncISPConfigMailMembers.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Enums\IspconfigType;
+use App\Models\IspconfigMember;
+use App\Models\Member;
+use App\Services\ISPConfig\ISPConfigMailService;
+use Illuminate\Console\Command;
+use function Laravel\Prompts\progress;
+
+class SyncISPConfigMailMembers extends Command
+{
+    protected $signature = 'sync:ispconfig-mail-members';
+    protected $description = 'Synchronise les services MAIL ISPConfig des membres - Email Retzien';
+
+    public function handle(): void
+    {
+        $this->info('Synchronisation ISPConfig MAIL');
+
+        $ispMail = new ISPConfigMailService();
+
+        //Récupération de tous les mail users
+        $mailUsers = collect($ispMail->getAllMailUsers());
+
+        $progressBar = progress(label: 'ISPConfig Mail Members import', steps: $mailUsers->count());
+        $progressBar->start();
+
+        $emailToMailUserId = $mailUsers
+            ->filter(fn ($u) => isset($u['email'], $u['mailuser_id']))
+            ->mapWithKeys(fn ($u) => [
+                strtolower($u['email']) => (int) $u['mailuser_id'],
+            ]);
+
+        $synced = 0;
+
+        // Parcours des membres
+        Member::whereNotNull('email')->chunk(100, function ($members) use (
+            $progressBar,
+            $emailToMailUserId,
+            $ispMail,
+            &$synced
+        ) {
+            foreach ($members as $member) {
+                $emails = array_map('trim', explode(';', $member->email));
+
+                $retzienEmail = collect($emails)
+                    ->map(fn ($e) => strtolower($e))
+                    ->first(fn ($e) => str_ends_with($e, '@retzien.fr'));
+
+                if (!$retzienEmail) {
+                    continue;
+                }
+
+                $mailUserId = $emailToMailUserId->get($retzienEmail);
+
+                if (!$mailUserId) {
+                    $this->warn("Aucun mail user ISPConfig pour {$retzienEmail}");
+                    continue;
+                }
+
+                //Récupération des données complètes de la boîte mail
+                $mailUserData = $ispMail->getMailUserDetails($retzienEmail);
+
+                // Création / mise à jour
+                IspconfigMember::updateOrCreate(
+                    [
+                        'member_id' => $member->id,
+                        //@todo : 'ispconfig_client_id' => ?,
+                        'type'      => IspconfigType::MAIL,
+                        'email'     => $retzienEmail,
+                    ],
+                    [
+                        'ispconfig_service_user_id' => $mailUserId,
+                        'data' => [
+                            // @todo: traiter plus tard le cas de plusieurs mail pour un adhérent
+                            'mailuser' => [$mailUserData],
+                        ],
+                    ]
+                );
+                $synced++;
+                $progressBar->advance();
+            }
+        });
+
+        $progressBar->finish();
+        $this->info("{$synced} services mail synchronisés");
+    }
+}

app/Console/Commands/SyncISPConfigWebMembers.php

@@ -0,0 +1,226 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Enums\IspconfigType;
+use App\Models\IspconfigMember;
+use App\Models\Member;
+use App\Services\ISPConfig\ISPConfigWebService;
+use Illuminate\Console\Command;
+use function Laravel\Prompts\progress;
+
+class SyncISPConfigWebMembers extends Command
+{
+    protected $signature = 'sync:ispconfig-web-members {--refresh-cache : Vider le cache avant la synchronisation}';
+    protected $description = 'Synchronise les services WEB ISPConfig des membres (via member->website_url)';
+
+    /**
+     * @throws \Exception
+     */
+    public function handle(): void
+    {
+        //@todo: Retrouver le client_id pour chaque adhérent
+
+        $this->info('Synchronisation ISPConfig WEB (via member->website_url)');
+
+        $ispWeb = new ISPConfigWebService();
+
+        // Vider le cache si demandé
+        if ($this->option('refresh-cache')) {
+            $this->info('Vidage du cache ISPConfig...');
+            $ispWeb->clearAllCache();
+        }
+
+        // Récupération de toutes les données ISPConfig en une seule fois (avec cache)
+        $this->info('Chargement des données ISPConfig...');
+        $allWebsites = collect($ispWeb->getAllWebsites());
+        $allDatabases = collect($ispWeb->getAllDatabases());
+        $allFtpUsers = collect($ispWeb->getAllFtpUsers());
+        $allShellUsers = collect($ispWeb->getAllShellUsers());
+        $allDnsZones = collect($ispWeb->getAllDnsZones());
+
+        $progressBar = progress(
+            label: 'ISPConfig Web Members import',
+            steps: Member::whereNotNull('website_url')->count()
+        );
+
+        $progressBar->start();
+
+        // Parcours des membres
+        Member::whereNotNull('website_url')->chunk(100, function ($members) use (
+            $allWebsites,
+            $allDatabases,
+            $allFtpUsers,
+            $allShellUsers,
+            $allDnsZones,
+            $ispWeb,
+            $progressBar
+        ) {
+            foreach ($members as $member) {
+
+                // Extraction des domaines depuis website_url
+                $memberDomains = collect(explode(';', $member->website_url))
+                    ->map(fn($url) => $this->normalizeDomain($url))
+                    ->filter()
+                    ->unique()
+                    ->values();
+
+                if ($memberDomains->isEmpty()) {
+                    $progressBar->advance();
+                    continue;
+                }
+
+                // Recherche des sites ISPConfig correspondants
+                $matchedWebsites = $allWebsites->filter(function ($site) use ($memberDomains, $ispWeb) {
+                    $siteDomain = strtolower($site['domain']);
+
+                    // Vérification du domaine principal
+                    if ($memberDomains->contains($siteDomain)) {
+                        return true;
+                    }
+
+                    // Récupération et vérification des alias (avec cache)
+                    $aliases = $ispWeb->getWebsiteAliases($site['domain_id']);
+                    foreach ($aliases as $alias) {
+                        if ($memberDomains->contains(strtolower($alias))) {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                });
+
+                if ($matchedWebsites->isEmpty()) {
+                    $progressBar->advance();
+                    continue;
+                }
+
+                // Construction des données pour chaque site
+                $sitesData = $matchedWebsites->map(function ($site) use (
+                    $allDatabases,
+                    $allFtpUsers,
+                    $allShellUsers,
+                    $allDnsZones,
+                    $ispWeb
+                ) {
+                    $domainId = $site['domain_id'];
+                    $sysGroupId = $site['sys_groupid'];
+                    $domain = $site['domain'];
+
+                    // Récupération des alias (avec cache)
+                    $aliases = $ispWeb->getWebsiteAliases($domainId);
+
+                    // Filtrage des bases de données pour ce site
+                    $databases = $allDatabases
+                        ->filter(fn($db) => $db['sys_groupid'] == $sysGroupId)
+                        ->map(fn($db) => [
+                            'database_id' => $db['database_id'],
+                            'database_name' => $db['database_name'],
+                            'database_user_id' => $db['database_user_id'],
+                            'database_type' => $db['type'],
+                        ])
+                        ->values();
+
+                    // Filtrage des utilisateurs FTP pour ce site
+                    $ftpUsers = $allFtpUsers
+                        ->filter(fn($ftp) => $ftp['parent_domain_id'] == $domainId)
+                        ->map(fn($ftp) => [
+                            'ftp_user_id' => $ftp['ftp_user_id'],
+                            'username' => $ftp['username'],
+                            'dir' => $ftp['dir'],
+                        ])
+                        ->values();
+
+                    // Filtrage des utilisateurs Shell pour ce site
+                    $shellUsers = $allShellUsers
+                        ->filter(fn($shell) => $shell['parent_domain_id'] == $domainId)
+                        ->map(fn($shell) => [
+                            'shell_user_id' => $shell['shell_user_id'],
+                            'username' => $shell['username'],
+                            'shell' => $shell['shell'],
+                            'chroot' => $shell['chroot'],
+                        ])
+                        ->values();
+
+                    // Filtrage des zones DNS pour ce site
+                    // Le champ 'origin' de la zone DNS correspond au domaine avec un point final
+                    $dnsZones = $allDnsZones
+                        ->filter(function ($zone) use ($domain, $aliases) {
+                            // Normalisation : retirer le point final de l'origin pour comparer
+                            $zoneOrigin = rtrim($zone['origin'], '.');
+
+                            // Vérifier le domaine principal
+                            if (strtolower($zoneOrigin) === strtolower($domain)) {
+                                return true;
+                            }
+
+                            // Vérifier les alias
+                            foreach ($aliases as $alias) {
+                                if (strtolower($zoneOrigin) === strtolower($alias)) {
+                                    return true;
+                                }
+                            }
+
+                            return false;
+                        })
+                        ->map(fn($zone) => [
+                            'id' => $zone['id'],
+                            'origin' => $zone['origin'],
+                            'ns' => $zone['ns'],
+                            'active' => $zone['active'],
+                            'dnssec_wanted' => $zone['dnssec_wanted'] ?? null,
+                            'dnssec_initialized' => $zone['dnssec_initialized'] ?? null,
+                        ])
+                        ->values();
+
+                    return [
+                        'domain_id' => $domainId,
+                        'domain' => $domain,
+                        'document_root' => $site['document_root'],
+                        'active' => $site['active'],
+                        'aliases' => $aliases,
+                        'databases' => $databases,
+                        'ftp_users' => $ftpUsers,
+                        'shell_users' => $shellUsers,
+                        'dns_zones' => $dnsZones,
+                    ];
+                });
+
+                // Création/mise à jour d'un enregistrement par site
+                foreach ($sitesData as $siteData) {
+                    IspconfigMember::updateOrCreate(
+                        [
+                            'member_id' => $member->id,
+                            'type' => IspconfigType::WEB,
+                            'ispconfig_service_user_id' => $siteData['domain_id'],
+                        ],
+                        [
+                            'data' => $siteData,
+                        ]
+                    );
+                }
+
+                $progressBar->advance();
+            }
+        });
+
+        $progressBar->finish();
+        $this->info('Synchronisation WEB terminée');
+    }
+
+    /**
+     * Normalise une URL vers un domaine
+     */
+    private function normalizeDomain(string $url): ?string
+    {
+        $url = trim($url);
+
+        if (!str_starts_with($url, 'http')) {
+            $url = 'https://' . $url;
+        }
+
+        $host = parse_url($url, PHP_URL_HOST);
+
+        return $host ? strtolower($host) : null;
+    }
+}

app/Console/Commands/SyncNextcloudMembers.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Member;
+use App\Models\NextCloudMember;
+use App\Services\Nextcloud\NextcloudService;
+use Illuminate\Console\Command;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Support\Facades\Log;
+use Symfony\Component\Console\Command\Command as CommandAlias;
+
+class SyncNextcloudMembers extends Command
+{
+    protected $signature = 'nextcloud:sync-members
+        {--dry-run : Ne pas écrire en base}
+        {--member= : Synchroniser un seul member_id}';
+
+    protected $description = 'Synchronise les comptes Nextcloud avec les adhérents';
+
+    public function __construct(
+        protected NextcloudService $nextcloud
+    ) {
+        parent::__construct();
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function handle(): int
+    {
+        $dryRun = $this->option('dry-run');
+        $memberFilter = $this->option('member');
+
+        $this->info(
+            $dryRun
+                ? 'DRY-RUN activé'
+                : 'Synchronisation Nextcloud → Members'
+        );
+
+        /** index des membres par email */
+        $members = Member::query()
+            ->where('email', 'like', '%@retzien.fr%')
+            ->when($memberFilter, fn ($q) => $q->where('id', $memberFilter))
+            ->get()
+            ->filter(fn (Member $m) => !empty($m->retzien_email))
+            ->keyBy(fn (Member $m) => strtolower($m->retzien_email));
+
+
+        if ($members->isEmpty()) {
+            $this->warn('Aucun membre à synchroniser');
+            return CommandAlias::SUCCESS;
+        }
+
+        $this->info("{$members->count()} membres candidats");
+
+        /**Récupération des users Nextcloud */
+        $userIds = $this->nextcloud->listUsers();
+
+        $this->info(count($userIds) . ' comptes Nextcloud trouvés');
+
+        $synced = 0;
+
+        foreach ($userIds as $userId) {
+            try {
+                $details = $this->nextcloud->getUserDetails($userId);
+
+                $email = strtolower($details['email'] ?? '');
+
+                if (!$email || !$members->has($email)) {
+                    continue;
+                }
+
+                $member = $members[$email];
+
+                $payload = [
+                    'member_id' => $member->id,
+                    'nextcloud_user_id' => $userId,
+                    'data' => [
+                        'email' => $email,
+                        'quota' => $details['quota'] ?? null,
+                        'groups' => $details['groups'] ?? [],
+                        'enabled' => !($details['enabled'] === false),
+                        'last_login' => $details['lastLogin'] ?? null,
+                        'raw' => $details, // utile pour debug
+                    ],
+                ];
+
+                if ($dryRun) {
+                    $this->line("[DRY-RUN] {$member->id} ← {$userId}");
+                } else {
+                    NextCloudMember::query()->updateOrCreate(
+                        [
+                            'member_id' => $member->id,
+                            'nextcloud_user_id' => $userId,
+                        ],
+                        $payload
+                    );
+                }
+
+                $synced++;
+
+            } catch (\Throwable $e) {
+                Log::error('Erreur sync Nextcloud', [
+                    'user_id' => $userId,
+                    'error' => $e->getMessage(),
+                ]);
+            }
+        }
+
+        $this->info("Synchronisation terminée ({$synced} comptes liés)");
+
+        return CommandAlias::SUCCESS;
+    }
+}

app/Enums/IspconfigType.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Enums;
+
+enum IspconfigType: string
+{
+    case MAIL = 'mail';
+    case WEB  = 'web';
+    case OTHER = 'other';
+
+    public function label(): string
+    {
+        return match ($this) {
+            self::MAIL  => 'Email',
+            self::WEB   => 'Hébergement',
+            self::OTHER => 'Autre',
+        };
+    }
+}

app/Filament/Resources/Members/Schemas/MemberForm.php

@@ -2,17 +2,21 @@
 
 namespace App\Filament\Resources\Members\Schemas;
 
+use App\Enums\IspconfigType;
 use App\Models\Member;
 use Filament\Actions\Action;
 use Filament\Forms\Components\DatePicker;
+use Filament\Forms\Components\Placeholder;
 use Filament\Forms\Components\Select;
 use Filament\Forms\Components\TextInput;
 use Filament\Forms\Components\Toggle;
-use Filament\Schemas\Components\Actions;
 use Filament\Schemas\Components\Grid;
 use Filament\Schemas\Components\Section;
 use Filament\Schemas\Schema;
-use Filament\Tables\Columns\Layout\Split;
+use Filament\Infolists\Components\TextEntry;
+use Filament\Infolists\Components\RepeatableEntry;
+use Filament\Infolists\Components\Actions;
+
 
 class MemberForm
 {
@@ -91,6 +95,58 @@ class MemberForm
                                             ->label(Member::getAttributeLabel('country')),
                                     ])
                                     ->columns(2),
+                                // Mail Retzien
+                                Section::make('Messagerie ISPConfig Retzien')
+                                    ->schema([
+                                        TextEntry::make('isp_mail_email')
+                                            ->label('Adresse email')
+                                            ->state(fn (?Member $record) =>
+                                                $record?->ispconfigMail()?->email ?? '—'
+                                            ),
+
+                                        TextEntry::make('isp_mail_user_id')
+                                            ->label('ID utilisateur ISPConfig (mailuser_id)')
+                                            ->state(fn (?Member $record) =>
+                                                $record?->ispconfigMail()?->ispconfig_service_user_id ?? '—'
+                                            ),
+
+                                        TextEntry::make('isp_mail_quota')
+                                            ->label('Quota')
+                                            ->state(function (?Member $record) {
+                                                $quota = $record?->ispconfigMail()?->data['mailuser']['quota'] ?? null;
+
+                                                return $quota
+                                                    ? "{$quota} Mo"
+                                                    : 'Non défini';
+                                            }),
+
+                                        TextEntry::make('isp_mail_domain')
+                                            ->label('Domaine')
+                                            ->state(fn (?Member $record) =>
+                                                $record?->ispconfigMail()?->data['mailuser']['domain'] ?? 'retzien.fr'
+                                            ),
+                                    ])
+                                    ->columns(2)
+                                    ->visible(fn (?Member $record) =>
+                                        $record?->ispconfigMail() !== null
+                                    ),
+
+                                // Hébergement
+
+                                Section::make('Hébergements Web')
+                                    ->schema([
+                                        Placeholder::make('ispconfigs_web_display')
+                                            ->label('')
+                                            ->content(fn (?Member $record) => view('filament.components.ispconfig-web-list', [
+                                                'ispconfigs' => $record?->ispconfigs()
+                                                        ->where('type', IspconfigType::WEB)
+                                                        ->get() ?? collect()
+                                            ]))
+                                    ])
+                                    ->visible(fn (?Member $record) =>
+                                    $record?->ispconfigs()->where('type', IspconfigType::WEB)->exists()
+                                    )
+                                // Fin Hébergement
                             ])
                             ->columnSpan(3),
                         Grid::make(1)

app/Filament/Resources/Memberships/Schemas/MembershipForm.php

@@ -9,7 +9,7 @@ use Filament\Forms\Components\CheckboxList;
 use Filament\Forms\Components\DatePicker;
 use Filament\Forms\Components\Select;
 use Filament\Forms\Components\TextInput;
-use Filament\Forms\Components\Toggle;
+use Filament\Infolists\Infolist;
 use Filament\Infolists\Components\TextEntry;
 use Filament\Schemas\Components\Grid;
 use Filament\Schemas\Components\Section;

app/Models/IspconfigMember.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\IspconfigType;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class IspconfigMember extends Model
+{
+    protected $table = 'ispconfigs_members';
+
+    protected $fillable = [
+        'member_id',
+        'ispconfig_client_id',
+        'ispconfig_service_user_id',
+        'email',
+        'type',
+        'data',
+    ];
+
+    protected $casts = [
+        'type' => IspconfigType::class,
+        'data' => 'array',
+    ];
+
+    public function member(): BelongsTo
+    {
+        return $this->belongsTo(Member::class);
+    }
+}

app/Models/Member.php

@@ -2,6 +2,7 @@
 
 namespace App\Models;
 
+use App\Enums\IspconfigType;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
@@ -108,6 +109,12 @@ class Member extends Model
         return "{$this->firstname} {$this->lastname}";
     }
 
+    public function getRetzienEmailAttribute(): string
+    {
+       $emails = explode(';', $this->email);
+       return collect($emails)->filter(fn($email) => str_contains($email, '@retzien.fr'))->first();
+    }
+
     public function user(): BelongsTo
     {
         return $this->belongsTo(User::class);
@@ -122,4 +129,28 @@ class Member extends Model
     {
         return $this->hasMany(Membership::class);
     }
+
+    public function ispconfigs(): HasMany
+    {
+        return $this->hasMany(IspconfigMember::class, 'member_id');
+    }
+
+    public function ispconfigMail(): ?IspconfigMember
+    {
+        return $this->ispconfigs()
+            ->where('type', IspconfigType::MAIL)
+            ->first();
+    }
+
+    public function ispconfigsWeb(): ?IspconfigMember
+    {
+        return $this->ispconfigs()
+            ->where('type', IspconfigType::WEB)
+            ->first();
+    }
+
+    public function nextcloudAccounts(): HasMany
+    {
+        return $this->hasMany(NextCloudMember::class, 'member_id');
+    }
 }

app/Models/NextCloudMember.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\IspconfigType;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class NextCloudMember extends Model
+{
+    protected $table = 'nextclouds_members';
+
+    protected $fillable = [
+        'member_id',
+        'nextcloud_user_id',
+        'data',
+    ];
+
+    protected $casts = [
+        'data' => 'array',
+    ];
+
+    public function member(): BelongsTo
+    {
+        return $this->belongsTo(Member::class);
+    }
+}

app/Services/Dolibarr/DolibarrService.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace App\Services;
+namespace App\Services\Dolibarr;
 
 use Illuminate\Http\Client\ConnectionException;
 use Illuminate\Http\Client\PendingRequest;
@@ -9,6 +9,7 @@ use Illuminate\Support\Facades\Http;
 class DolibarrService
 {
     protected string $baseUrl;
+    protected string $htaccessUrl;
     protected string $username;
     protected string $password;
     protected string $apiKey;
@@ -16,6 +17,7 @@ class DolibarrService
     public function __construct()
     {
         $this->baseUrl = config('services.dolibarr.base_url');
+        $this->htaccessUrl = config('services.dolibarr.htaccess_url');
         $this->username = config('services.dolibarr.username');
         $this->password = config('services.dolibarr.password');
         $this->apiKey   = config('services.dolibarr.api_key');
@@ -58,4 +60,23 @@ class DolibarrService
 
         return $response->json();
     }
+
+    /**
+     * Update a member with custom data
+     *
+     * @param int|string $id The Dolibarr member ID (rowid)
+     * @param array $data Array of attributes to update (e.g. ['email' => 'new@email.com', 'array_options' => ['options_custom' => 'val']])
+     * @throws ConnectionException
+     */
+    public function updateMember(int|string $id, array $data): bool
+    {
+        $response = $this->client()->put(
+            $this->baseUrl . '/members/' . $id,
+            $data
+        );
+
+        return $response->successful();
+    }
+
+
 }

app/Services/ISPConfig/ISPConfigMailService.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace App\Services\ISPConfig;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
+
+class ISPConfigMailService extends ISPConfigService
+{
+    public function __construct()
+    {
+        parent::__construct('mail_server');
+    }
+
+    /**
+     * Récupère tous les domaines mail
+     */
+    public function getAllMailDomains(): array
+    {
+        return Cache::remember(
+            "ispconfig.mail.domains.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('mail_domain_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * Récupère tous les utilisateurs mail
+     */
+    public function getAllMailUsers(): array
+    {
+        return Cache::remember(
+            "ispconfig.mail.users.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('mail_user_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * Récupère les domaines mail d'un client ISPConfig
+     */
+    public function getMailDomainsForClient(int $ispConfigClientId): Collection
+    {
+        $allDomains = $this->getAllMailDomains();
+
+        return collect($allDomains)->filter(function ($domain) use ($ispConfigClientId) {
+            return isset($domain['sys_groupid']) && $domain['sys_groupid'] == $ispConfigClientId;
+        });
+    }
+
+    /**
+     * Récupère les boîtes mail pour un domaine
+     */
+    public function getMailUsersForDomain(string $domain): Collection
+    {
+        $allUsers = $this->getAllMailUsers();
+
+        return collect($allUsers)->filter(function ($user) use ($domain) {
+            return str_ends_with($user['email'], '@' . $domain);
+        });
+    }
+
+    /**
+     * Récupère les détails d'une boîte mail
+     */
+    public function getMailUserDetails(string $email): ?array
+    {
+        $allUsers = $this->getAllMailUsers();
+
+        $user = collect($allUsers)->firstWhere('email', $email);
+
+        if (!$user) {
+            return null;
+        }
+
+        return [
+            'email' => $user['email'],
+            'name' => $user['name'] ?? '',
+            'quota' => (int) ($user['quota'] ?? 0),
+            'usage' => (int) ($user['maildir_usage'] ?? 0),
+            'usage_mb' => round(($user['maildir_usage'] ?? 0) / 1024 / 1024, 2),
+            'active' => $user['postfix'] === 'y',
+            'imap_enabled' => $user['disableimap'] === 'n',
+            'pop3_enabled' => $user['disablepop3'] === 'n',
+            'smtp_enabled' => $user['disablesmtp'] === 'n',
+            'autoresponder' => $user['autoresponder'] === 'y',
+            'spam_filter' => $user['move_junk'] === 'y',
+        ];
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function updateMailUser(string $email, array $changes): bool
+    {
+        // On retrouve l'utilisateur
+        $user = collect($this->getAllMailUsers())
+            ->firstWhere('email', $email);
+
+        if (!$user) {
+            return false;
+        }
+
+        $mailuserId = (int) $user['mailuser_id'];
+
+        // On récupère l'enregistrement COMPLET (OBLIGATOIRE)
+        $mailUserRecord = $this->call('mail_user_get', [
+            $mailuserId
+        ]);
+
+        if (!is_array($mailUserRecord)) {
+            throw new \RuntimeException('mail_user_get did not return array');
+        }
+
+        // On applique les changements
+        foreach ($changes as $key => $value) {
+            $mailUserRecord[$key] = $value;
+        }
+
+        // appel conforme EXACT à l’exemple ISPConfig
+        $result = $this->call('mail_user_update', [
+            0,              // client_id (ADMIN)
+            $mailuserId,    // primary_id
+            $mailUserRecord // FULL RECORD
+        ]);
+
+        return (bool) $result;
+    }
+
+
+}

app/Services/ISPConfig/ISPConfigService.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace App\Services\ISPConfig;
+
+use Exception;
+use Illuminate\Support\Facades\Cache;
+use SoapClient;
+use SoapFault;
+use Illuminate\Support\Facades\Log;
+
+class ISPConfigService
+{
+    protected ?SoapClient $client = null;
+    protected ?string $sessionId = null;
+    protected array $config;
+    protected string $serverType;
+
+    /**
+     * @throws Exception
+     */
+    public function __construct(string $serverType = 'mail_server')
+    {
+        $this->serverType = $serverType;
+        $this->config = config("services.ispconfig.servers.{$serverType}");
+
+        if (!$this->config) {
+            throw new Exception("ISPConfig server configuration not found for: {$serverType}");
+        }
+    }
+
+    protected function connect(): void
+    {
+        if ($this->client !== null && $this->sessionId !== null) {
+            return;
+        }
+
+        try {
+            $this->client = new SoapClient(null, [
+                'location' => $this->config['soap_location'],
+                'uri' => $this->config['soap_uri'],
+                'trace' => 1,
+                'exceptions' => 1,
+                'stream_context' => stream_context_create([
+                    'ssl' => [
+                        'verify_peer' => false,
+                        'verify_peer_name' => false,
+                    ]
+                ])
+            ]);
+
+            $this->sessionId = $this->client->login(
+                $this->config['username'],
+                $this->config['password']
+            );
+
+            Log::info("ISPConfig connected", [
+                'server' => $this->serverType,
+                'session_id' => $this->sessionId
+            ]);
+
+        } catch (SoapFault $e) {
+            Log::error("ISPConfig connection failed", [
+                'server' => $this->serverType,
+                'error' => $e->getMessage()
+            ]);
+            throw new Exception("Failed to connect to ISPConfig: " . $e->getMessage());
+        }
+    }
+
+    public function disconnect(): void
+    {
+        if ($this->client && $this->sessionId) {
+            try {
+                $this->client->logout($this->sessionId);
+                Log::info("ISPConfig disconnected", ['server' => $this->serverType]);
+            } catch (SoapFault $e) {
+                Log::warning("ISPConfig logout failed", [
+                    'server' => $this->serverType,
+                    'error' => $e->getMessage()
+                ]);
+            }
+
+            $this->sessionId = null;
+            $this->client = null;
+        }
+    }
+
+    /**
+     * @throws Exception
+     */
+    protected function call(string $method, array $params = []): mixed
+    {
+        $this->connect();
+
+        try {
+            array_unshift($params, $this->sessionId);
+
+            $result = $this->client->__soapCall($method, $params);
+
+            Log::debug("ISPConfig API call", [
+                'method' => $method,
+                'server' => $this->serverType,
+                'success' => true
+            ]);
+
+            return $result;
+
+        } catch (SoapFault $e) {
+            Log::error("ISPConfig API call failed", [
+                'method' => $method,
+                'server' => $this->serverType,
+                'error' => $e->getMessage()
+            ]);
+            throw new Exception("ISPConfig API call failed: " . $e->getMessage());
+        }
+    }
+
+    public function __destruct()
+    {
+        $this->disconnect();
+    }
+
+    /**
+     * Récupère tous les clients
+     */
+    public function getAllClients(): array
+    {
+        return Cache::remember(
+            "ispconfig.mail.clients.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('client_get_all')
+        );
+    }
+
+    public function getClientData(string $clientId): array
+    {
+        return $this->call('client_get', ['client_id' => $clientId]);
+    }
+}

app/Services/ISPConfig/ISPConfigWebService.php

@@ -0,0 +1,266 @@
+<?php
+
+namespace App\Services\ISPConfig;
+
+use Illuminate\Support\Facades\Cache;
+
+class ISPConfigWebService extends ISPConfigService
+{
+    public function __construct()
+    {
+        parent::__construct('web_server');
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function getAllWebsites(): array
+    {
+        return Cache::remember(
+            "ispconfig.web.websites.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('sites_web_domain_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function getAllDatabases(): array
+    {
+        return Cache::remember(
+            "ispconfig.web.databases.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('sites_database_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function getAllFtpUsers(): array
+    {
+        return Cache::remember(
+            "ispconfig.web.ftp.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('sites_ftp_user_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function getAllShellUsers(): array
+    {
+        return Cache::remember(
+            "ispconfig.web.shell.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('sites_shell_user_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function getAllDnsZones(): array
+    {
+        return Cache::remember(
+            "ispconfig.web.dns-zones.all",
+            config('services.ispconfig.cache_ttl'),
+            fn() => $this->call('dns_zone_get', ['primary_id' => -1])
+        );
+    }
+
+    /**
+     * Récupère la liste des alias d'un site web
+     *
+     * @param int $domainId
+     * @return array
+     * @throws \Exception
+     */
+    public function getWebsiteAliases(int $domainId): array
+    {
+        return Cache::remember(
+            "ispconfig.web.aliases.{$domainId}",
+            config('services.ispconfig.cache_ttl', 3600),
+            function () use ($domainId) {
+                try {
+                    $siteInfo = $this->call('sites_web_domain_get', ['domain_id' => $domainId]);
+
+                    if (empty($siteInfo)) {
+                        return [];
+                    }
+
+                    $site = $siteInfo;
+
+                    if (empty($site['alias'])) {
+                        return [];
+                    }
+
+                    $aliases = array_map('trim', explode(',', $site['alias']));
+                    return array_values(array_filter($aliases, fn($alias) => !empty($alias)));
+
+                } catch (\Exception $e) {
+                    \Log::error("Erreur lors de la récupération des alias pour le domaine {$domainId}: " . $e->getMessage());
+                    return [];
+                }
+            }
+        );
+    }
+
+    /**
+     * Récupère la liste des bases de données d'un site en filtrant depuis toutes les BDD
+     *
+     * @param int $sysGroupId
+     * @return array
+     * @throws \Exception
+     */
+    public function getWebsiteDatabases(int $sysGroupId): array
+    {
+        // Récupération de toutes les bases de données
+        $allDatabases = $this->getAllDatabases();
+
+        // Filtrage par sys_groupid
+        return collect($allDatabases)
+            ->filter(fn($db) => $db['sys_groupid'] == $sysGroupId)
+            ->map(fn($db) => [
+                'database_id' => $db['database_id'],
+                'database_name' => $db['database_name'],
+                'database_user' => $db['database_user'],
+                'database_type' => $db['type'],
+                'active' => $db['active'],
+                'remote_access' => $db['remote_access'],
+                'remote_ips' => $db['remote_ips'] ?? ''
+            ])
+            ->values()
+            ->toArray();
+    }
+
+    /**
+     * Récupère la liste des utilisateurs FTP d'un site en filtrant depuis tous les comptes FTP
+     *
+     * @param int $domainId
+     * @return array
+     * @throws \Exception
+     */
+    public function getWebsiteFtpUsers(int $domainId): array
+    {
+        // Récupération de tous les utilisateurs FTP
+        $allFtpUsers = $this->getAllFtpUsers();
+
+        // Filtrage par parent_domain_id
+        return collect($allFtpUsers)
+            ->filter(fn($ftp) => $ftp['parent_domain_id'] == $domainId)
+            ->map(fn($ftp) => [
+                'ftp_user_id' => $ftp['ftp_user_id'],
+                'username' => $ftp['username'],
+                'dir' => $ftp['dir'],
+                'quota_size' => $ftp['quota_size'],
+                'active' => $ftp['active'],
+                'uid' => $ftp['uid'],
+                'gid' => $ftp['gid']
+            ])
+            ->values()
+            ->toArray();
+    }
+
+    /**
+     * Récupère la liste des utilisateurs Shell d'un site en filtrant depuis tous les comptes Shell
+     *
+     * @param int $domainId
+     * @return array
+     * @throws \Exception
+     */
+    public function getWebsiteShellUsers(int $domainId): array
+    {
+        // Récupération de tous les utilisateurs Shell (avec cache)
+        $allShellUsers = $this->getAllShellUsers();
+
+        // Filtrage par parent_domain_id
+        return collect($allShellUsers)
+            ->filter(fn($shell) => $shell['parent_domain_id'] == $domainId)
+            ->map(fn($shell) => [
+                'shell_user_id' => $shell['shell_user_id'],
+                'username' => $shell['username'],
+                'dir' => $shell['dir'],
+                'shell' => $shell['shell'],
+                'puser' => $shell['puser'],
+                'pgroup' => $shell['pgroup'],
+                'quota_size' => $shell['quota_size'],
+                'active' => $shell['active'],
+                'chroot' => $shell['chroot'],
+                'ssh_rsa' => !empty($shell['ssh_rsa'])
+            ])
+            ->values()
+            ->toArray();
+    }
+
+    /**
+     * Récupère toutes les informations complètes d'un site (alias, BDD, FTP, Shell)
+     *
+     * @param int $domainId
+     * @return array|null
+     * @throws \Exception
+     */
+    public function getWebsiteCompleteInfo(int $domainId): ?array
+    {
+        return Cache::remember(
+            "ispconfig.web.complete.{$domainId}",
+            config('services.ispconfig.cache_ttl', 3600),
+            function () use ($domainId) {
+                $siteInfo = $this->call('sites_web_domain_get', ['domain_id' => $domainId]);
+
+                if (empty($siteInfo)) {
+                    return null;
+                }
+
+                $site = $siteInfo;
+
+                // Récupérer les alias
+                $aliases = [];
+                if (!empty($site['alias'])) {
+                    $aliases = array_values(array_filter(array_map('trim', explode(',', $site['alias']))));
+                }
+
+                return [
+                    'domain_id' => $site['domain_id'],
+                    'domain' => $site['domain'],
+                    'document_root' => $site['document_root'],
+                    'active' => $site['active'],
+                    'sys_groupid' => $site['sys_groupid'],
+                    'aliases' => $aliases,
+                    'databases' => $this->getWebsiteDatabases($domainId, $site['sys_groupid']),
+                    'ftp_users' => $this->getWebsiteFtpUsers($domainId),
+                    'shell_users' => $this->getWebsiteShellUsers($domainId)
+                ];
+            }
+        );
+    }
+
+    /**
+     * Vide le cache pour un domaine spécifique
+     *
+     * @param int $domainId
+     * @return void
+     */
+    public function clearDomainCache(int $domainId): void
+    {
+        Cache::forget("ispconfig.web.aliases.{$domainId}");
+        Cache::forget("ispconfig.web.complete.{$domainId}");
+    }
+
+    /**
+     * Vide tout le cache ISPConfig Web
+     *
+     * @return void
+     */
+    public function clearAllCache(): void
+    {
+        Cache::forget("ispconfig.web.websites.all");
+        Cache::forget("ispconfig.web.databases.all");
+        Cache::forget("ispconfig.web.ftp.all");
+        Cache::forget("ispconfig.web.shell.all");
+        Cache::forget("ispconfig.web.dns-zones.all");
+        Cache::forget("ispconfig.web.domain-alias.all");
+    }
+}

app/Services/ISPConfigService.php

@@ -1,89 +0,0 @@
-<?php
-
-namespace App\Services;
-
-use Illuminate\Support\Facades\Log;
-use SoapClient;
-use SoapFault;
-use Exception;
-
-class ISPConfigService
-{
-    protected ?SoapClient $client = null;
-    protected ?string $sessionId = null;
-
-    public function __construct()
-    {
-    }
-
-    /**
-     * ISPConfig Login
-     */
-    public function connect(string $type): void
-    {
-        // Type = 'hosting' or 'mailbox'
-        $username = $username ?? config('services.ispconfig'.$type.'.username');
-        $password = $password ?? config('services.ispconfig'.$type.'.password');
-
-        try {
-            $this->client = new SoapClient(null, [
-                'location' => config('services.ispconfig' . $type . '.base_url'),
-                'trace' => true,
-                'exceptions' => true,
-                'stream_context' => stream_context_create([
-                    'ssl' => [
-                        'verify_peer' => false,
-                        'verify_peer_name' => false,
-                        'allow_self_signed' => true,
-                    ],
-                ]),
-            ]);
-
-            $this->sessionId = $this->client->login($username, $password);
-        } catch (SoapFault $e) {
-            throw new Exception("An error occurred : " . $e->getMessage());
-        }
-    }
-
-    /**
-     * Get all clients
-     */
-    public function getAllClients(string $username = null, string $password = null): array
-    {
-        if (!$this->sessionId) {
-            $this->connect($username, $password);
-        }
-
-        try {
-            $clientIds = $this->client->client_get_all($this->sessionId);
-            $clients = [];
-
-            foreach ($clientIds as $id) {
-                $details = $this->client->client_get($this->sessionId, (int)$id);
-                if (!empty($details)) {
-                    $clients[] = (array) $details;
-                }
-            }
-
-            return $clients;
-        } catch (SoapFault $e) {
-            throw new Exception("An error occurred : " . $e->getMessage());
-        } finally {
-            $this->disconnect();
-        }
-    }
-
-    /**
-     * Logout
-     */
-    public function disconnect(): void
-    {
-        if ($this->client && $this->sessionId) {
-            try {
-                $this->client->logout($this->sessionId);
-            } catch (SoapFault $e) {
-                Log::info('ISP Config logout succeeded');
-            }
-        }
-    }
-}

app/Services/MemberService.php

@@ -6,15 +6,9 @@ use App\Events\MemberRegistered;
 use App\Models\Member;
 use App\Models\MemberGroup;
 use App\Models\Package;
-use Carbon\Carbon;
 
 class MemberService
 {
-    public function __construct()
-    {
-        // No repositories used in this project
-    }
-
     public function registerNewMember(array $data): Member
     {
         // Check if the member already exists

app/Services/Nextcloud/NextcloudService.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace App\Services\Nextcloud;
+
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Http\Client\PendingRequest;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+class NextcloudService
+{
+    protected PendingRequest $http;
+
+    public function __construct()
+    {
+        $this->http = Http::withBasicAuth(
+            config('services.nextcloud.user'),
+            config('services.nextcloud.password')
+        )
+            ->withHeaders([
+                'OCS-APIRequest' => 'true',
+                'Accept' => 'application/json',
+            ])
+            ->baseUrl(config('services.nextcloud.url') . '/ocs/v1.php');
+    }
+
+    /**
+     * Désactive un utilisateur Nextcloud à partir de son email
+     * @throws ConnectionException
+     */
+    public function disableUserByEmail(string $email): void
+    {
+        $userId = $this->findUserIdByEmail($email);
+
+        if (!$userId) {
+            Log::warning("Utilisateur Nextcloud introuvable", ['email' => $email]);
+            return;
+        }
+
+        $response = $this->http->put("/cloud/users/{$userId}/disable");
+
+        if (!$response->successful()) {
+            throw new \RuntimeException("Erreur désactivation Nextcloud {$userId}");
+        }
+    }
+
+    /**
+     * Trouve le userId Nextcloud à partir de l’email
+     */
+    protected function findUserIdByEmail(string $email): ?string
+    {
+        return Cache::remember(
+            'nextcloud.user_id.' . md5($email),
+            now()->addDays(7),
+            function () use ($email) {
+                return $this->resolveUserIdByEmail($email);
+            }
+        );
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    protected function resolveUserIdByEmail(string $email): ?string
+    {
+        $response = $this->http->get('/cloud/users');
+
+        $users = $response->json('ocs.data.users') ?? [];
+
+        foreach ($users as $userId) {
+            $details = $this->http->get("/cloud/users/{$userId}");
+
+            if (
+                $details->successful() &&
+                $details->json('ocs.data.email') === $email
+            ) {
+                return $userId;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function listUsers(): array
+    {
+        return $this->http
+            ->get('/cloud/users')
+            ->json('ocs.data.users') ?? [];
+    }
+
+    /**
+     * @throws ConnectionException
+     */
+    public function getUserDetails(string $userId): array
+    {
+        return $this->http
+            ->get("/cloud/users/{$userId}")
+            ->json('ocs.data') ?? [];
+    }
+
+
+}

config/services.php

@@ -37,22 +37,40 @@ return [
 
     'dolibarr' => [
         'base_url' => env('DOLIBARR_URL'),
+        'htaccess_url' => env('DOLIBARR_URL_HTACCESS'),
         'username' => env('DOLIBARR_USERNAME'),
         'password' => env('DOLIBARR_PWD'),
         'api_key' => env('DOLIBARR_APIKEY')
     ],
-
     'ispconfig' => [
-        'hosting' => [
-            'base_url' => env('HOSTING_ISPAPI_URL'),
-            'username' => env('HOSTING_ISPAPI_USERNAME'),
-            'password' => env('HOSTING_ISPAPI_PWD'),
+        'servers' => [
+            'mail_server' => [
+                'name' => 'ISP Config Mail',
+                'soap_location' => env('ISPCONFIG_MAIL_SOAP_LOCATION'),
+                'soap_uri' => env('ISPCONFIG_MAIL_SOAP_URI'),
+                'username' => env('ISPCONFIG_MAIL_USERNAME'),
+                'password' => env('ISPCONFIG_MAIL_PASSWORD'),
+            ],
+            'web_server' => [
+                'name' => 'ISP Config Web',
+                'soap_location' => env('ISPCONFIG_WEB_SOAP_LOCATION'),
+                'soap_uri' => env('ISPCONFIG_WEB_SOAP_URI'),
+                'username' => env('ISPCONFIG_WEB_USERNAME'),
+                'password' => env('ISPCONFIG_WEB_PASSWORD'),
+            ],
+            'test_server' => [
+                'name' => 'ISP Config TEST',
+                'soap_location' => env('ISPCONFIG_TEST_SOAP_LOCATION'),
+                'soap_uri' => env('ISPCONFIG_TEST_SOAP_URI'),
+                'username' => env('ISPCONFIG_TEST_USERNAME'),
+                'password' => env('ISPCONFIG_TEST_PASSWORD'),
+            ],
+        ],
+        'cache_ttl' => env('ISPCONFIG_CACHE_TTL', 300), // 5 minutes
+    ],
+    'nextcloud' => [
+        'url' => env('NEXTCLOUD_URL'),
+        'user' => env('NEXTCLOUD_USERNAME'),
+        'password' => env('NEXTCLOUD_PASSWORD')
     ],
-        'mailbox' => [
-            'base_url' => env('MAIL_ISPAPI_URL'),
-            'username' => env('MAIL_ISPAPI_USERNAME'),
-            'password' => env('MAIL_ISPAPI_PWD'),
-        ]
-    ]
-
 ];

database/migrations/2025_12_30_134044_create_ispconfigs_members_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('ispconfigs_members', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('member_id')->constrained('members')->onDelete('NO ACTION');
+            $table->string('ispconfig_client_id')->nullable();
+            $table->string('ispconfig_service_user_id')->nullable();
+            $table->string('email')->nullable();
+            $table->enum('type', ['mail', 'web', 'other']);
+            $table->json('data')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('ispconfigs_members');
+    }
+};

database/migrations/2026_01_04_134658_create_webdomains_members_table.php

@@ -0,0 +1,27 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('webdomains_members', function (Blueprint $table) {
+            $table->id();
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('webdomains_members');
+    }
+};

database/migrations/2026_01_19_105050_create_nextclouds_members_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('nextclouds_members', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('member_id')->constrained('members')->onDelete('NO ACTION');
+            $table->string('nextcloud_user_id')->nullable();
+            $table->json('data')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('nextclouds_members');
+    }
+};

resources/views/filament/components/ispconfig-web-list.blade.php

@@ -0,0 +1,36 @@
+<div class="space-y-4">
+    @foreach($ispconfigs as $ispconfig)
+        <div class="border rounded-lg p-4 bg-white dark:bg-gray-800">
+            <div class="flex items-start justify-between mb-3">
+                <h4 class="text-lg font-semibold text-gray-900 dark:text-white">
+                    {{ $ispconfig->data['domain'] ?? 'Domaine non défini' }}
+                </h4>
+                <div>
+                    <a
+                        href="#"
+                        target="_blank"
+                        class="inline-flex items-center gap-1 text-sm text-primary-600 hover:text-primary-700 dark:text-primary-400 font-medium"
+                    >
+                        Gérer dans ISPConfig
+
+                    </a>
+                </div>
+            </div>
+
+            <div class="grid grid-cols-2 gap-3 text-sm">
+                @foreach($ispconfig->data as $key => $value)
+                    @if(!is_array($value) && !is_null($value))
+                        <div class="flex flex-col">
+                            <span class="text-gray-500 dark:text-gray-400 text-xs">
+                                {{ ucfirst(str_replace('_', ' ', $key)) }}
+                            </span>
+                            <span class="font-medium text-gray-900 dark:text-white">
+                                {{ $value }}
+                            </span>
+                        </div>
+                    @endif
+                @endforeach
+            </div>
+        </div>
+    @endforeach
+</div>

routes/dev-routes.php

@@ -3,7 +3,7 @@
 use Illuminate\Support\Facades\Route;
 
 Route::get('/call-dolibarr', function () {
-    $call = new App\Services\DolibarrService;
+    $call = new \App\Services\Dolibarr\DolibarrService;
     $members = $call->getAllMembers();
     // find specific
     $userData = collect($members)->firstWhere('id', 124); // Isabelle AK

routes/web.php

@@ -17,6 +17,35 @@ Route::middleware(['auth', 'verified'])->group(function () {
     })->name('dashboard');
 });
 
+// TEST
+
+/*Route::get('/test/sync-ispconfig', function () {
+
+    if (!app()->isLocal()) {
+        abort(403);
+    }
+
+    Artisan::call('sync:ispconfig-web-members');
+
+    return response()->json([
+        'status' => 'ok',
+        'output' => Artisan::output(),
+    ]);
+});
+
+Route::get('/test/isp-mails', function() {
+    $ispService = new \App\Services\ISPConfig\ISPConfigMailService;
+
+    return $ispService->getAllMailDomains();
+});*/
+
+Route::get('/test-dolibarr', function () {
+   $dolibarrService = new \App\Services\Dolibarr\DolibarrService();
+
+   $members = $dolibarrService->getAllMembers();
+
+   dd($members);
+});
 
 require __DIR__.'/settings.php';
 require __DIR__.'/auth.php';