From 5bf927cde6b6c9743a9ef1fe2ff669fac25204e4 Mon Sep 17 00:00:00 2001
From: "Misha M.-Kupriyanov" <kupriyanov@strato.de>
Date: Thu, 23 Oct 2025 17:31:19 +0200
Subject: [PATCH 1/5] IONOS(ionos-mail): add domain preference for IONOS mail
 configuration

Signed-off-by: Misha M.-Kupriyanov <kupriyanov@strato.de>
---
 lib/Controller/PageController.php             |  8 +++-
 lib/Service/IONOS/IonosConfigService.php      | 48 +++++++++++++++++++
 src/components/ionos/NewEmailAddressTab.vue   |  6 ++-
 src/init.js                                   |  4 ++
 tests/Unit/Controller/PageControllerTest.php  | 10 +++-
 .../Service/IONOS/IonosConfigServiceTest.php  | 45 +++++++++++++++++
 6 files changed, 118 insertions(+), 3 deletions(-)

diff --git a/lib/Controller/PageController.php b/lib/Controller/PageController.php
index df82aafb34..2ea0f62352 100644
--- a/lib/Controller/PageController.php
+++ b/lib/Controller/PageController.php
@@ -21,6 +21,7 @@
 use OCA\Mail\Service\AliasesService;
 use OCA\Mail\Service\Classification\ClassificationSettingsService;
 use OCA\Mail\Service\InternalAddressService;
+use OCA\Mail\Service\IONOS\IonosConfigService;
 use OCA\Mail\Service\OutboxService;
 use OCA\Mail\Service\QuickActionsService;
 use OCA\Mail\Service\SmimeService;
@@ -74,7 +75,8 @@ class PageController extends Controller {
 	private InternalAddressService $internalAddressService;
 	private QuickActionsService $quickActionsService;
 
-	public function __construct(string $appName,
+	public function __construct(
+		string $appName,
 		IRequest $request,
 		IURLGenerator $urlGenerator,
 		IConfig $config,
@@ -97,6 +99,7 @@ public function __construct(string $appName,
 		InternalAddressService $internalAddressService,
 		IAvailabilityCoordinator $availabilityCoordinator,
 		QuickActionsService $quickActionsService,
+		private IonosConfigService $ionosConfigService,
 	) {
 		parent::__construct($appName, $request);
 
@@ -208,9 +211,12 @@ public function index(): TemplateResponse {
 
 		$user = $this->userSession->getUser();
 		$response = new TemplateResponse($this->appName, 'index');
+
+
 		$this->initialStateService->provideInitialState('preferences', [
 			'attachment-size-limit' => $this->config->getSystemValue('app.mail.attachment-size-limit', 0),
 			'ionos-mailconfig-enabled' => $this->config->getAppValue('mail', 'ionos-mailconfig-enabled', 'no') === 'yes',
+			'ionos-mailconfig-domain' => $this->ionosConfigService->getMailDomain(),
 			'app-version' => $this->config->getAppValue('mail', 'installed_version'),
 			'external-avatars' => $this->preferences->getPreference($this->currentUserId, 'external-avatars', 'true'),
 			'layout-mode' => $this->preferences->getPreference($this->currentUserId, 'layout-mode', 'vertical-split'),
diff --git a/lib/Service/IONOS/IonosConfigService.php b/lib/Service/IONOS/IonosConfigService.php
index a429972324..6606c510bb 100644
--- a/lib/Service/IONOS/IonosConfigService.php
+++ b/lib/Service/IONOS/IonosConfigService.php
@@ -13,7 +13,10 @@
 use OCP\Exceptions\AppConfigException;
 use OCP\IAppConfig;
 use OCP\IConfig;
+use Pdp\Domain;
+use Pdp\Rules;
 use Psr\Log\LoggerInterface;
+use Throwable;
 
 /**
  * Service for managing IONOS API configuration
@@ -125,4 +128,49 @@ public function getApiConfig(): array {
 			'basicAuthPass' => $this->getBasicAuthPassword(),
 		];
 	}
+
+	/**
+	 * Get the mail domain from customer domain
+	 *
+	 * Extracts the registrable domain (mail domain) from the customer domain
+	 * configured in system settings.
+	 */
+	public function getMailDomain(): string {
+		$customerDomain = $this->config->getSystemValue('ncw.customerDomain', '');
+		return $this->extractMailDomain($customerDomain);
+	}
+
+	/**
+	 * Extract the registrable domain (mail domain) from a customer domain.
+	 *
+	 * Uses the Public Suffix List via Pdp library to properly extract the
+	 * registrable domain, handling multi-level TLDs like .co.uk correctly.
+	 *
+	 * Examples:
+	 * - foo.bar.lol -> bar.lol
+	 * - mail.test.co.uk -> test.co.uk
+	 * - sub.domain.example.com -> example.com
+	 *
+	 * @param string $customerDomain The full customer domain
+	 * @return string The extracted mail domain, or empty string if input is empty
+	 */
+	private function extractMailDomain(string $customerDomain): string {
+		if (empty($customerDomain)) {
+			return '';
+		}
+
+		try {
+			$publicSuffixList = Rules::fromPath(__DIR__ . '/../../../resources/public_suffix_list.dat');
+			$domain = Domain::fromIDNA2008($customerDomain);
+			$result = $publicSuffixList->resolve($domain);
+			return $result->registrableDomain()->toString();
+		} catch (Throwable $e) {
+			// Fallback to simple extraction if Pdp fails
+			$parts = explode('.', $customerDomain);
+			if (count($parts) >= 2) {
+				return $parts[count($parts) - 2] . '.' . $parts[count($parts) - 1];
+			}
+			return $customerDomain;
+		}
+	}
 }
diff --git a/src/components/ionos/NewEmailAddressTab.vue b/src/components/ionos/NewEmailAddressTab.vue
index d0b99e8a85..228889b600 100644
--- a/src/components/ionos/NewEmailAddressTab.vue
+++ b/src/components/ionos/NewEmailAddressTab.vue
@@ -23,7 +23,7 @@
 		<p v-if="emailAddress && !isValidEmail(emailAddress)" class="account-form--error">
 			{{ t('mail', 'Please enter an email of the format name@example.com') }}
 		</p>
-		<span class="email-domain-hint">@myworkspace.com</span>
+		<span class="email-domain-hint">@{{ emailDomain }}</span>
 		<div class="account-form__submit-buttons">
 			<NcButton class="account-form__submit-button"
 				type="primary"
@@ -95,6 +95,10 @@ export default {
 				? t('mail', 'Creating account...')
 				: t('mail', 'Create & Connect')
 		},
+
+		emailDomain() {
+			return this.mainStore.getPreference('ionos-mailconfig-domain', 'myworkspace.com')
+		},
 	},
 	methods: {
 		async submitForm() {
diff --git a/src/init.js b/src/init.js
index d055872bc9..bc9529ad6a 100644
--- a/src/init.js
+++ b/src/init.js
@@ -41,6 +41,10 @@ export default function initAfterAppCreation() {
 		key: 'ionos-mailconfig-enabled',
 		value: preferences['ionos-mailconfig-enabled'],
 	})
+	mainStore.savePreferenceMutation({
+		key: 'ionos-mailconfig-domain',
+		value: preferences['ionos-mailconfig-domain'],
+	})
 	mainStore.savePreferenceMutation({
 		key: 'external-avatars',
 		value: preferences['external-avatars'],
diff --git a/tests/Unit/Controller/PageControllerTest.php b/tests/Unit/Controller/PageControllerTest.php
index fd7bc37923..21f75432ee 100644
--- a/tests/Unit/Controller/PageControllerTest.php
+++ b/tests/Unit/Controller/PageControllerTest.php
@@ -21,6 +21,7 @@
 use OCA\Mail\Service\AliasesService;
 use OCA\Mail\Service\Classification\ClassificationSettingsService;
 use OCA\Mail\Service\InternalAddressService;
+use OCA\Mail\Service\IONOS\IonosConfigService;
 use OCA\Mail\Service\MailManager;
 use OCA\Mail\Service\OutboxService;
 use OCA\Mail\Service\QuickActionsService;
@@ -113,6 +114,8 @@ class PageControllerTest extends TestCase {
 
 	private IAvailabilityCoordinator&MockObject $availabilityCoordinator;
 
+	private IonosConfigService&MockObject $ionosConfigService;
+
 	protected function setUp(): void {
 		parent::setUp();
 
@@ -139,6 +142,7 @@ protected function setUp(): void {
 		$this->internalAddressService = $this->createMock(InternalAddressService::class);
 		$this->availabilityCoordinator = $this->createMock(IAvailabilityCoordinator::class);
 		$this->quickActionsService = $this->createMock(QuickActionsService::class);
+		$this->ionosConfigService = $this->createMock(IonosConfigService::class);
 
 		$this->controller = new PageController(
 			$this->appName,
@@ -164,6 +168,7 @@ protected function setUp(): void {
 			$this->internalAddressService,
 			$this->availabilityCoordinator,
 			$this->quickActionsService,
+			$this->ionosConfigService,
 		);
 	}
 
@@ -282,8 +287,10 @@ public function testIndex(): void {
 				$this->returnValue(''),
 				$this->returnValue('cron'),
 				$this->returnValue('yes'),
-				$this->returnValue('no')
 			);
+		$this->ionosConfigService->expects($this->once())
+			->method('getMailDomain')
+			->willReturn('example.tld');
 		$this->aiIntegrationsService->expects(self::exactly(4))
 			->method('isLlmProcessingEnabled')
 			->willReturn(false);
@@ -335,6 +342,7 @@ public function testIndex(): void {
 					'reply-mode' => 'bottom',
 					'app-version' => '1.2.3',
 					'ionos-mailconfig-enabled' => false,
+					'ionos-mailconfig-domain' => 'example.tld',
 					'collect-data' => 'true',
 					'start-mailbox-id' => '123',
 					'tag-classified-messages' => 'false',
diff --git a/tests/Unit/Service/IONOS/IonosConfigServiceTest.php b/tests/Unit/Service/IONOS/IonosConfigServiceTest.php
index cf27ab3911..b4391f3e53 100644
--- a/tests/Unit/Service/IONOS/IonosConfigServiceTest.php
+++ b/tests/Unit/Service/IONOS/IonosConfigServiceTest.php
@@ -172,4 +172,49 @@ public function testGetApiConfigSuccess(): void {
 			'basicAuthPass' => 'testpass',
 		], $result);
 	}
+
+	public function testGetMailDomainWithValidDomain(): void {
+		$this->config->method('getSystemValue')
+			->with('ncw.customerDomain', '')
+			->willReturn('mail.example.com');
+
+		$result = $this->service->getMailDomain();
+		$this->assertEquals('example.com', $result);
+	}
+
+	public function testGetMailDomainWithEmptyDomain(): void {
+		$this->config->method('getSystemValue')
+			->with('ncw.customerDomain', '')
+			->willReturn('');
+
+		$result = $this->service->getMailDomain();
+		$this->assertEquals('', $result);
+	}
+
+	public function testGetMailDomainWithMultiLevelTld(): void {
+		$this->config->method('getSystemValue')
+			->with('ncw.customerDomain', '')
+			->willReturn('mail.test.co.uk');
+
+		$result = $this->service->getMailDomain();
+		$this->assertEquals('test.co.uk', $result);
+	}
+
+	public function testGetMailDomainWithSubdomain(): void {
+		$this->config->method('getSystemValue')
+			->with('ncw.customerDomain', '')
+			->willReturn('foo.bar.lol');
+
+		$result = $this->service->getMailDomain();
+		$this->assertEquals('bar.lol', $result);
+	}
+
+	public function testGetMailDomainWithSimpleDomain(): void {
+		$this->config->method('getSystemValue')
+			->with('ncw.customerDomain', '')
+			->willReturn('example.com');
+
+		$result = $this->service->getMailDomain();
+		$this->assertEquals('example.com', $result);
+	}
 }

From 7db5843dd0454aef8fea8fe3aa5c9f3ee4307f76 Mon Sep 17 00:00:00 2001
From: "Misha M.-Kupriyanov" <kupriyanov@strato.de>
Date: Wed, 29 Oct 2025 14:40:32 +0100
Subject: [PATCH 2/5] IONOS(ionos-mail): fix isValidEmail check

Signed-off-by: Misha M.-Kupriyanov <kupriyanov@strato.de>
---
 src/components/ionos/NewEmailAddressTab.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/ionos/NewEmailAddressTab.vue b/src/components/ionos/NewEmailAddressTab.vue
index 228889b600..4672bdb32c 100644
--- a/src/components/ionos/NewEmailAddressTab.vue
+++ b/src/components/ionos/NewEmailAddressTab.vue
@@ -72,7 +72,7 @@ export default {
 		},
 		isValidEmail: {
 			type: Function,
-			required: true,
+			default: () => {},
 		},
 	},
 	data() {

From 279d9fc5612f029d5db17e284779803e9b65bcfe Mon Sep 17 00:00:00 2001
From: "Misha M.-Kupriyanov" <kupriyanov@strato.de>
Date: Wed, 29 Oct 2025 16:23:18 +0100
Subject: [PATCH 3/5] IONOS(ionos-mail): refactor email account creation to use
 config service methods

Signed-off-by: Misha M.-Kupriyanov <kupriyanov@strato.de>
---
 lib/Service/IONOS/IonosMailService.php        | 13 ++--
 .../Service/IONOS/IonosMailServiceTest.php    | 78 +++++++------------
 2 files changed, 36 insertions(+), 55 deletions(-)

diff --git a/lib/Service/IONOS/IonosMailService.php b/lib/Service/IONOS/IonosMailService.php
index e7218de40b..c0bad5c5c3 100644
--- a/lib/Service/IONOS/IonosMailService.php
+++ b/lib/Service/IONOS/IonosMailService.php
@@ -42,23 +42,22 @@ public function __construct(
 	 * @throws AppConfigException
 	 */
 	public function createEmailAccount(string $emailAddress): MailAccountConfig {
-		$config = $this->configService->getApiConfig();
 		$userId = $this->getCurrentUserId();
 		$userName = $this->extractUsername($emailAddress);
 		$domain = $this->extractDomain($emailAddress);
 
 		$this->logger->debug('Sending request to mailconfig service', [
-			'extRef' => $config['extRef'],
+			'extRef' => $this->configService->getExternalReference(),
 			'emailAddress' => $emailAddress,
-			'apiBaseUrl' => $config['apiBaseUrl']
+			'apiBaseUrl' => $this->configService->getApiBaseUrl()
 		]);
 
 		$client = $this->apiClientService->newClient([
-			'auth' => [$config['basicAuthUser'], $config['basicAuthPass']],
-			'verify' => !$config['allowInsecure'],
+			'auth' => [$this->configService->getBasicAuthUser(), $this->configService->getBasicAuthPassword()],
+			'verify' => !$this->configService->getAllowInsecure(),
 		]);
 
-		$apiInstance = $this->apiClientService->newEventAPIApi($client, $config['apiBaseUrl']);
+		$apiInstance = $this->apiClientService->newEventAPIApi($client, $this->configService->getApiBaseUrl());
 
 		$mailCreateData = new MailCreateData();
 		$mailCreateData->setNextcloudUserId($userId);
@@ -72,7 +71,7 @@ public function createEmailAccount(string $emailAddress): MailAccountConfig {
 
 		try {
 			$this->logger->debug('Send message to mailconfig service', ['data' => $mailCreateData]);
-			$result = $apiInstance->createMailbox(self::BRAND, $config['extRef'], $mailCreateData);
+			$result = $apiInstance->createMailbox(self::BRAND, $this->configService->getExternalReference(), $mailCreateData);
 
 			if ($result instanceof ErrorMessage) {
 				$this->logger->error('Failed to create ionos mail', ['status code' => $result->getStatus(), 'message' => $result->getMessage()]);
diff --git a/tests/Unit/Service/IONOS/IonosMailServiceTest.php b/tests/Unit/Service/IONOS/IonosMailServiceTest.php
index a038319efc..e36ad07c49 100644
--- a/tests/Unit/Service/IONOS/IonosMailServiceTest.php
+++ b/tests/Unit/Service/IONOS/IonosMailServiceTest.php
@@ -54,14 +54,11 @@ public function testCreateEmailAccountSuccess(): void {
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -136,14 +133,11 @@ public function testCreateEmailAccountWithApiException(): void {
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -175,14 +169,11 @@ public function testCreateEmailAccountWithErrorMessageResponse(): void {
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -216,14 +207,11 @@ public function testCreateEmailAccountWithUnknownResponseType(): void {
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -252,14 +240,11 @@ public function testCreateEmailAccountWithNoUserSession(): void {
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock no user session
 		$this->userSession->method('getUser')->willReturn(null);
@@ -323,14 +308,11 @@ public function testSslModeNormalization(string $apiSslMode, string $expectedSec
 		$emailAddress = 'test@example.com';
 
 		// Mock config
-		$this->configService->method('getApiConfig')
-			->willReturn([
-				'extRef' => 'test-ext-ref',
-				'apiBaseUrl' => 'https://api.example.com',
-				'allowInsecure' => false,
-				'basicAuthUser' => 'testuser',
-				'basicAuthPass' => 'testpass',
-			]);
+		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
+		$this->configService->method('getApiBaseUrl')->willReturn('https://api.example.com');
+		$this->configService->method('getAllowInsecure')->willReturn(false);
+		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
+		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);

From 40c6fca44cd3f8113029b367c3a672842a62bf23 Mon Sep 17 00:00:00 2001
From: "Misha M.-Kupriyanov" <kupriyanov@strato.de>
Date: Thu, 30 Oct 2025 10:36:10 +0100
Subject: [PATCH 4/5] IONOS(ionos-mail): simplify success response by removing
 email address parameter

Signed-off-by: Misha M.-Kupriyanov <kupriyanov@strato.de>
---
 lib/Service/IONOS/IonosMailService.php | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/Service/IONOS/IonosMailService.php b/lib/Service/IONOS/IonosMailService.php
index c0bad5c5c3..d1a77dd6a7 100644
--- a/lib/Service/IONOS/IonosMailService.php
+++ b/lib/Service/IONOS/IonosMailService.php
@@ -78,7 +78,7 @@ public function createEmailAccount(string $emailAddress): MailAccountConfig {
 				throw new ServiceException('Failed to create ionos mail', $result->getStatus());
 			}
 			if ($result instanceof MailAccountResponse) {
-				return $this->buildSuccessResponse($emailAddress, $result);
+				return $this->buildSuccessResponse($result);
 			}
 
 			$this->logger->debug('Failed to create ionos mail: Unknown response type', ['data' => $result ]);
@@ -169,11 +169,10 @@ private function normalizeSslMode(string $apiSslMode): string {
 	/**
 	 * Build success response with mail configuration
 	 *
-	 * @param string $emailAddress
 	 * @param MailAccountResponse $response
 	 * @return MailAccountConfig
 	 */
-	private function buildSuccessResponse(string $emailAddress, MailAccountResponse $response): MailAccountConfig {
+	private function buildSuccessResponse(MailAccountResponse $response): MailAccountConfig {
 		$smtpServer = $response->getServer()->getSmtp();
 		$imapServer = $response->getServer()->getImap();
 
@@ -194,7 +193,7 @@ private function buildSuccessResponse(string $emailAddress, MailAccountResponse
 		);
 
 		return new MailAccountConfig(
-			email: $emailAddress,
+			email: $response->getEmail(),
 			imap: $imapConfig,
 			smtp: $smtpConfig,
 		);

From 6d16117cc33723ca23e6f6ea5fd70a8c4a2b200c Mon Sep 17 00:00:00 2001
From: "Misha M.-Kupriyanov" <kupriyanov@strato.de>
Date: Wed, 29 Oct 2025 14:42:00 +0100
Subject: [PATCH 5/5] IONOS(ionos-mail): refactor email input handling to
 separate user and domain

Signed-off-by: Misha M.-Kupriyanov <kupriyanov@strato.de>
---
 lib/Controller/IonosAccountsController.php    | 24 +++---
 lib/Service/IONOS/IonosMailService.php        | 42 +---------
 src/components/ionos/NewEmailAddressTab.vue   | 27 ++++---
 .../IonosAccountsControllerTest.php           | 42 ++++------
 .../Service/IONOS/IonosMailServiceTest.php    | 80 ++++++-------------
 5 files changed, 69 insertions(+), 146 deletions(-)

diff --git a/lib/Controller/IonosAccountsController.php b/lib/Controller/IonosAccountsController.php
index de8e448704..9a1a5b700d 100644
--- a/lib/Controller/IonosAccountsController.php
+++ b/lib/Controller/IonosAccountsController.php
@@ -38,13 +38,10 @@ public function __construct(
 	}
 
 	// Helper: input validation
-	private function validateInput(string $accountName, string $emailAddress): ?JSONResponse {
-		if ($accountName === '' || $emailAddress === '') {
+	private function validateInput(string $accountName, string $emailUser): ?JSONResponse {
+		if ($accountName === '' || $emailUser === '') {
 			return new JSONResponse(['success' => false, 'message' => self::ERR_ALL_FIELDS_REQUIRED, 'error' => self::ERR_IONOS_API_ERROR], 400);
 		}
-		if (!filter_var($emailAddress, FILTER_VALIDATE_EMAIL)) {
-			return new JSONResponse(['success' => false, 'message' => 'Invalid email address format', 'error' => self::ERR_IONOS_API_ERROR], 400);
-		}
 		return null;
 	}
 
@@ -52,20 +49,19 @@ private function validateInput(string $accountName, string $emailAddress): ?JSON
 	 * @NoAdminRequired
 	 */
 	#[TrapError]
-	public function create(string $accountName, string $emailAddress): JSONResponse {
-		if ($error = $this->validateInput($accountName, $emailAddress)) {
+	public function create(string $accountName, string $emailUser): JSONResponse {
+		if ($error = $this->validateInput($accountName, $emailUser)) {
 			return $error;
 		}
 
 		try {
-			$this->logger->info('Starting IONOS email account creation', [ 'emailAddress' => $emailAddress, 'accountName' => $accountName ]);
-			$ionosResponse = $this->ionosMailService->createEmailAccount($emailAddress);
+			$this->logger->info('Starting IONOS email account creation', [ 'emailAddress' => $emailUser, 'accountName' => $accountName ]);
+			$ionosResponse = $this->ionosMailService->createEmailAccount($emailUser);
 
-			$this->logger->info('IONOS email account created successfully', [ 'emailAddress' => $emailAddress ]);
-			return $this->createNextcloudMailAccount($accountName, $emailAddress, $ionosResponse);
+			$this->logger->info('IONOS email account created successfully', [ 'emailAddress' => $ionosResponse->getEmail() ]);
+			return $this->createNextcloudMailAccount($accountName, $ionosResponse);
 		} catch (ServiceException $e) {
 			$data = [
-				'emailAddress' => $emailAddress,
 				'error' => self::ERR_IONOS_API_ERROR,
 				'statusCode' => $e->getCode(),
 			];
@@ -77,13 +73,13 @@ public function create(string $accountName, string $emailAddress): JSONResponse
 		}
 	}
 
-	private function createNextcloudMailAccount(string $accountName, string $emailAddress, MailAccountConfig $mailConfig): JSONResponse {
+	private function createNextcloudMailAccount(string $accountName, MailAccountConfig $mailConfig): JSONResponse {
 		$imap = $mailConfig->getImap();
 		$smtp = $mailConfig->getSmtp();
 
 		return $this->accountsController->create(
 			$accountName,
-			$emailAddress,
+			$mailConfig->getEmail(),
 			$imap->getHost(),
 			$imap->getPort(),
 			$imap->getSecurity(),
diff --git a/lib/Service/IONOS/IonosMailService.php b/lib/Service/IONOS/IonosMailService.php
index d1a77dd6a7..4e9e802a79 100644
--- a/lib/Service/IONOS/IonosMailService.php
+++ b/lib/Service/IONOS/IonosMailService.php
@@ -41,14 +41,14 @@ public function __construct(
 	 * @throws ServiceException
 	 * @throws AppConfigException
 	 */
-	public function createEmailAccount(string $emailAddress): MailAccountConfig {
+	public function createEmailAccount(string $userName): MailAccountConfig {
 		$userId = $this->getCurrentUserId();
-		$userName = $this->extractUsername($emailAddress);
-		$domain = $this->extractDomain($emailAddress);
+		$domain = $this->configService->getMailDomain();
 
 		$this->logger->debug('Sending request to mailconfig service', [
 			'extRef' => $this->configService->getExternalReference(),
-			'emailAddress' => $emailAddress,
+			'userName' => $userName,
+			'domain' => $domain,
 			'apiBaseUrl' => $this->configService->getApiBaseUrl()
 		]);
 
@@ -97,40 +97,6 @@ public function createEmailAccount(string $emailAddress): MailAccountConfig {
 		}
 	}
 
-	/**
-	 * Extract domain from email address
-	 *
-	 * @throws ServiceException
-	 */
-	public function extractDomain(string $emailAddress): string {
-		$atPosition = strrchr($emailAddress, '@');
-		if ($atPosition === false) {
-			throw new ServiceException('Invalid email address: unable to extract domain');
-		}
-		$domain = substr($atPosition, 1);
-		if ($domain === '') {
-			throw new ServiceException('Invalid email address: unable to extract domain');
-		}
-		return $domain;
-	}
-
-	/**
-	 * Extract username from email address
-	 *
-	 * @throws ServiceException
-	 */
-	public function extractUsername(string $emailAddress): string {
-		$atPosition = strrpos($emailAddress, '@');
-		if ($atPosition === false) {
-			throw new ServiceException('Invalid email address: unable to extract username');
-		}
-		$userName = substr($emailAddress, 0, $atPosition);
-		if ($userName === '') {
-			throw new ServiceException('Invalid email address: unable to extract username');
-		}
-		return $userName;
-	}
-
 	/**
 	 * Get the current user ID
 	 *
diff --git a/src/components/ionos/NewEmailAddressTab.vue b/src/components/ionos/NewEmailAddressTab.vue
index 4672bdb32c..cb4c290f49 100644
--- a/src/components/ionos/NewEmailAddressTab.vue
+++ b/src/components/ionos/NewEmailAddressTab.vue
@@ -13,15 +13,15 @@
 			@change="clearAllFeedback"
 			autofocus />
 		<NcInputField id="ionos-email-address"
-			v-model="emailAddress"
-			:label="t('mail', 'Mail address')"
-			type="email"
-			:placeholder="t('mail', 'Mail address')"
+			v-model="emailUser"
+			:label="t('mail', 'User')"
+			type="text"
+			:placeholder="t('mail', 'User')"
 			:disabled="loading || localLoading"
 			required
 			@change="clearAllFeedback" />
-		<p v-if="emailAddress && !isValidEmail(emailAddress)" class="account-form--error">
-			{{ t('mail', 'Please enter an email of the format name@example.com') }}
+		<p v-if="emailUser && !isValidEmail(fullEmailAddress)" class="account-form--error">
+			{{ t('mail', 'Please enter a valid email user name') }}
 		</p>
 		<span class="email-domain-hint">@{{ emailDomain }}</span>
 		<div class="account-form__submit-buttons">
@@ -78,16 +78,21 @@ export default {
 	data() {
 		return {
 			accountName: '',
-			emailAddress: '',
+			emailUser: '',
 			localLoading: false,
 			feedback: null,
 		}
 	},
 	computed: {
 		...mapStores(useMainStore),
+		fullEmailAddress() {
+			return this.emailUser ? `${this.emailUser}@${this.emailDomain}` : ''
+		},
+
 		isFormValid() {
 			return this.accountName
-				&& this.isValidEmail(this.emailAddress)
+				&& this.emailUser
+				&& this.isValidEmail(this.fullEmailAddress)
 		},
 
 		buttonText() {
@@ -108,7 +113,7 @@ export default {
 			try {
 				const account = await this.callIonosAPI({
 					accountName: this.accountName,
-					emailAddress: this.emailAddress,
+					emailUser: this.emailUser,
 				})
 
 				logger.debug(`account ${account.id} created`, { account })
@@ -151,11 +156,11 @@ export default {
 			}
 		},
 
-		async callIonosAPI({ accountName, emailAddress }) {
+		async callIonosAPI({ accountName, emailUser }) {
 			const url = generateUrl('/apps/mail/api/ionos/accounts')
 
 			return axios
-				.post(url, { accountName, emailAddress })
+				.post(url, { accountName, emailUser })
 				.then((resp) => resp.data.data)
 				.then(fixAccountId)
 				.catch((e) => {
diff --git a/tests/Unit/Controller/IonosAccountsControllerTest.php b/tests/Unit/Controller/IonosAccountsControllerTest.php
index 1e8c6f61d2..ad43b0085d 100644
--- a/tests/Unit/Controller/IonosAccountsControllerTest.php
+++ b/tests/Unit/Controller/IonosAccountsControllerTest.php
@@ -55,14 +55,14 @@ protected function setUp(): void {
 
 	public function testCreateWithMissingFields(): void {
 		// Test with empty account name
-		$response = $this->controller->create('', 'test@example.com');
+		$response = $this->controller->create('', 'testuser');
 		$this->assertEquals(400, $response->getStatus());
 		$data = $response->getData();
 		$this->assertFalse($data['success']);
 		$this->assertEquals('All fields are required', $data['message']);
 		$this->assertEquals('IONOS_API_ERROR', $data['error']);
 
-		// Test with empty email address
+		// Test with empty email user
 		$response = $this->controller->create('Test Account', '');
 		$this->assertEquals(400, $response->getStatus());
 		$data = $response->getData();
@@ -71,17 +71,9 @@ public function testCreateWithMissingFields(): void {
 		$this->assertEquals('IONOS_API_ERROR', $data['error']);
 	}
 
-	public function testCreateWithInvalidEmailFormat(): void {
-		$response = $this->controller->create('Test Account', 'invalid-email');
-		$this->assertEquals(400, $response->getStatus());
-		$data = $response->getData();
-		$this->assertFalse($data['success']);
-		$this->assertEquals('Invalid email address format', $data['message']);
-		$this->assertEquals('IONOS_API_ERROR', $data['error']);
-	}
-
 	public function testCreateSuccess(): void {
 		$accountName = 'Test Account';
+		$emailUser = 'test';
 		$emailAddress = 'test@example.com';
 
 		// Create MailAccountConfig DTO
@@ -109,7 +101,7 @@ public function testCreateSuccess(): void {
 
 		// Mock successful IONOS mail service response
 		$this->ionosMailService->method('createEmailAccount')
-			->with($emailAddress)
+			->with($emailUser)
 			->willReturn($mailAccountConfig);
 
 		// Mock account creation response
@@ -135,7 +127,7 @@ public function testCreateSuccess(): void {
 			)
 			->willReturn($accountResponse);
 
-		$response = $this->controller->create($accountName, $emailAddress);
+		$response = $this->controller->create($accountName, $emailUser);
 
 		// The controller now directly returns the AccountsController response
 		$this->assertSame($accountResponse, $response);
@@ -143,11 +135,11 @@ public function testCreateSuccess(): void {
 
 	public function testCreateWithServiceException(): void {
 		$accountName = 'Test Account';
-		$emailAddress = 'test@example.com';
+		$emailUser = 'test';
 
 		// Mock IONOS mail service to throw ServiceException
 		$this->ionosMailService->method('createEmailAccount')
-			->with($emailAddress)
+			->with($emailUser)
 			->willThrowException(new ServiceException('Failed to create email account'));
 
 		$this->logger
@@ -156,29 +148,27 @@ public function testCreateWithServiceException(): void {
 			->with(
 				'IONOS service error: Failed to create email account',
 				[
-					'emailAddress' => $emailAddress,
 					'error' => 'IONOS_API_ERROR',
 					'statusCode' => 0,
 				]
 			);
 
 		$expectedResponse = \OCA\Mail\Http\JsonResponse::fail([
-			'emailAddress' => 'test@example.com',
 			'error' => 'IONOS_API_ERROR',
 			'statusCode' => 0,
 		]);
-		$response = $this->controller->create($accountName, $emailAddress);
+		$response = $this->controller->create($accountName, $emailUser);
 
 		self::assertEquals($expectedResponse, $response);
 	}
 
 	public function testCreateWithServiceExceptionWithStatusCode(): void {
 		$accountName = 'Test Account';
-		$emailAddress = 'test@example.com';
+		$emailUser = 'test';
 
 		// Mock IONOS mail service to throw ServiceException with HTTP 409 (Duplicate)
 		$this->ionosMailService->method('createEmailAccount')
-			->with($emailAddress)
+			->with($emailUser)
 			->willThrowException(new ServiceException('Duplicate email account', 409));
 
 		$this->logger
@@ -187,29 +177,27 @@ public function testCreateWithServiceExceptionWithStatusCode(): void {
 			->with(
 				'IONOS service error: Duplicate email account',
 				[
-					'emailAddress' => $emailAddress,
 					'error' => 'IONOS_API_ERROR',
 					'statusCode' => 409,
 				]
 			);
 
 		$expectedResponse = \OCA\Mail\Http\JsonResponse::fail([
-			'emailAddress' => 'test@example.com',
 			'error' => 'IONOS_API_ERROR',
 			'statusCode' => 409,
 		]);
-		$response = $this->controller->create($accountName, $emailAddress);
+		$response = $this->controller->create($accountName, $emailUser);
 
 		self::assertEquals($expectedResponse, $response);
 	}
 
 	public function testCreateWithGenericException(): void {
 		$accountName = 'Test Account';
-		$emailAddress = 'test@example.com';
+		$emailUser = 'test';
 
 		// Mock IONOS mail service to throw a generic exception
 		$this->ionosMailService->method('createEmailAccount')
-			->with($emailAddress)
+			->with($emailUser)
 			->willThrowException(new \Exception('Generic error'));
 
 		$expectedResponse = \OCA\Mail\Http\JsonResponse::error('Could not create account',
@@ -217,7 +205,7 @@ public function testCreateWithGenericException(): void {
 			[],
 			0
 		);
-		$response = $this->controller->create($accountName, $emailAddress);
+		$response = $this->controller->create($accountName, $emailUser);
 
 		self::assertEquals($expectedResponse, $response);
 	}
@@ -274,7 +262,7 @@ public function testCreateNextcloudMailAccount(): void {
 		$method = $reflection->getMethod('createNextcloudMailAccount');
 		$method->setAccessible(true);
 
-		$result = $method->invoke($this->controller, $accountName, $emailAddress, $mailConfig);
+		$result = $method->invoke($this->controller, $accountName, $mailConfig);
 
 		$this->assertSame($expectedResponse, $result);
 	}
diff --git a/tests/Unit/Service/IONOS/IonosMailServiceTest.php b/tests/Unit/Service/IONOS/IonosMailServiceTest.php
index e36ad07c49..94842f920b 100644
--- a/tests/Unit/Service/IONOS/IonosMailServiceTest.php
+++ b/tests/Unit/Service/IONOS/IonosMailServiceTest.php
@@ -51,7 +51,9 @@ protected function setUp(): void {
 	}
 
 	public function testCreateEmailAccountSuccess(): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
+		$domain = 'example.com';
+		$emailAddress = $userName . '@' . $domain;
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -59,6 +61,7 @@ public function testCreateEmailAccountSuccess(): void {
 		$this->configService->method('getAllowInsecure')->willReturn(false);
 		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
 		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
+		$this->configService->method('getMailDomain')->willReturn($domain);
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -113,7 +116,7 @@ public function testCreateEmailAccountSuccess(): void {
 
 		$apiInstance->method('createMailbox')->willReturn($mailAccountResponse);
 
-		$result = $this->service->createEmailAccount($emailAddress);
+		$result = $this->service->createEmailAccount($userName);
 
 		$this->assertInstanceOf(MailAccountConfig::class, $result);
 		$this->assertEquals($emailAddress, $result->getEmail());
@@ -130,7 +133,8 @@ public function testCreateEmailAccountSuccess(): void {
 	}
 
 	public function testCreateEmailAccountWithApiException(): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
+		$domain = 'example.com';
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -138,6 +142,7 @@ public function testCreateEmailAccountWithApiException(): void {
 		$this->configService->method('getAllowInsecure')->willReturn(false);
 		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
 		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
+		$this->configService->method('getMailDomain')->willReturn($domain);
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -162,11 +167,12 @@ public function testCreateEmailAccountWithApiException(): void {
 		$this->expectException(ServiceException::class);
 		$this->expectExceptionMessage('Failed to create ionos mail');
 
-		$this->service->createEmailAccount($emailAddress);
+		$this->service->createEmailAccount($userName);
 	}
 
 	public function testCreateEmailAccountWithErrorMessageResponse(): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
+		$domain = 'example.com';
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -174,6 +180,7 @@ public function testCreateEmailAccountWithErrorMessageResponse(): void {
 		$this->configService->method('getAllowInsecure')->willReturn(false);
 		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
 		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
+		$this->configService->method('getMailDomain')->willReturn($domain);
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -200,11 +207,12 @@ public function testCreateEmailAccountWithErrorMessageResponse(): void {
 		$this->expectException(ServiceException::class);
 		$this->expectExceptionMessage('Failed to create ionos mail');
 
-		$this->service->createEmailAccount($emailAddress);
+		$this->service->createEmailAccount($userName);
 	}
 
 	public function testCreateEmailAccountWithUnknownResponseType(): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
+		$domain = 'example.com';
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -212,6 +220,7 @@ public function testCreateEmailAccountWithUnknownResponseType(): void {
 		$this->configService->method('getAllowInsecure')->willReturn(false);
 		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
 		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
+		$this->configService->method('getMailDomain')->willReturn($domain);
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -233,11 +242,11 @@ public function testCreateEmailAccountWithUnknownResponseType(): void {
 		$this->expectException(ServiceException::class);
 		$this->expectExceptionMessage('Failed to create ionos mail');
 
-		$this->service->createEmailAccount($emailAddress);
+		$this->service->createEmailAccount($userName);
 	}
 
 	public function testCreateEmailAccountWithNoUserSession(): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -252,51 +261,7 @@ public function testCreateEmailAccountWithNoUserSession(): void {
 		$this->expectException(ServiceException::class);
 		$this->expectExceptionMessage('No user session found');
 
-		$this->service->createEmailAccount($emailAddress);
-	}
-
-	public function testExtractDomainSuccess(): void {
-		$result = $this->service->extractDomain('user@example.com');
-		$this->assertEquals('example.com', $result);
-
-		$result = $this->service->extractDomain('test.user@subdomain.example.com');
-		$this->assertEquals('subdomain.example.com', $result);
-	}
-
-	public function testExtractDomainWithNoAtSign(): void {
-		$this->expectException(ServiceException::class);
-		$this->expectExceptionMessage('Invalid email address: unable to extract domain');
-
-		$this->service->extractDomain('invalid-email');
-	}
-
-	public function testExtractDomainWithEmptyDomain(): void {
-		$this->expectException(ServiceException::class);
-		$this->expectExceptionMessage('Invalid email address: unable to extract domain');
-
-		$this->service->extractDomain('user@');
-	}
-
-	public function testExtractUsernameSuccess(): void {
-		$result = $this->service->extractUsername('user@example.com');
-		$this->assertEquals('user', $result);
-
-		$result = $this->service->extractUsername('test.user@subdomain.example.com');
-		$this->assertEquals('test.user', $result);
-	}
-
-	public function testExtractUsernameWithNoAtSign(): void {
-		$this->expectException(ServiceException::class);
-		$this->expectExceptionMessage('Invalid email address: unable to extract username');
-
-		$this->service->extractUsername('invalid-email');
-	}
-
-	public function testExtractUsernameWithEmptyUsername(): void {
-		$this->expectException(ServiceException::class);
-		$this->expectExceptionMessage('Invalid email address: unable to extract username');
-
-		$this->service->extractUsername('@example.com');
+		$this->service->createEmailAccount($userName);
 	}
 
 	/**
@@ -305,7 +270,9 @@ public function testExtractUsernameWithEmptyUsername(): void {
 	 * @dataProvider sslModeNormalizationProvider
 	 */
 	public function testSslModeNormalization(string $apiSslMode, string $expectedSecurity): void {
-		$emailAddress = 'test@example.com';
+		$userName = 'test';
+		$domain = 'example.com';
+		$emailAddress = $userName . '@' . $domain;
 
 		// Mock config
 		$this->configService->method('getExternalReference')->willReturn('test-ext-ref');
@@ -313,6 +280,7 @@ public function testSslModeNormalization(string $apiSslMode, string $expectedSec
 		$this->configService->method('getAllowInsecure')->willReturn(false);
 		$this->configService->method('getBasicAuthUser')->willReturn('testuser');
 		$this->configService->method('getBasicAuthPassword')->willReturn('testpass');
+		$this->configService->method('getMailDomain')->willReturn($domain);
 
 		// Mock user session
 		$user = $this->createMock(IUser::class);
@@ -360,7 +328,7 @@ public function testSslModeNormalization(string $apiSslMode, string $expectedSec
 
 		$apiInstance->method('createMailbox')->willReturn($mailAccountResponse);
 
-		$result = $this->service->createEmailAccount($emailAddress);
+		$result = $this->service->createEmailAccount($userName);
 
 		$this->assertEquals($expectedSecurity, $result->getImap()->getSecurity());
 		$this->assertEquals($expectedSecurity, $result->getSmtp()->getSecurity());