mirror of
https://github.com/coollabsio/coolify.git
synced 2026-11-15 09:12:32 -04:00
033f0c84da
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: peaklabs-dev <122374094+peaklabs-dev@users.noreply.github.com> Co-authored-by: Aditya Tripathi <aditya@climactic.co>
570 lines
21 KiB
PHP
570 lines
21 KiB
PHP
<?php
|
|
|
|
namespace App\Livewire\Notifications;
|
|
|
|
use App\Livewire\Concerns\ManagesSmtpServers;
|
|
use App\Livewire\Notifications\Concerns\TogglesNotificationEvents;
|
|
use App\Models\EmailNotificationSettings;
|
|
use App\Models\Team;
|
|
use App\Notifications\Test;
|
|
use App\Rules\SafeSmtpHost;
|
|
use App\Rules\ValidHostname;
|
|
use App\Support\SmtpPresets;
|
|
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
|
|
use Illuminate\Support\Facades\RateLimiter;
|
|
use Illuminate\Validation\Rule;
|
|
use Illuminate\Validation\ValidationException;
|
|
use Livewire\Attributes\Computed;
|
|
use Livewire\Attributes\Locked;
|
|
use Livewire\Attributes\Validate;
|
|
use Livewire\Component;
|
|
|
|
class Email extends Component
|
|
{
|
|
use AuthorizesRequests, ManagesSmtpServers, TogglesNotificationEvents;
|
|
|
|
protected $listeners = ['refresh' => '$refresh'];
|
|
|
|
#[Locked]
|
|
public Team $team;
|
|
|
|
#[Locked]
|
|
public EmailNotificationSettings $settings;
|
|
|
|
#[Locked]
|
|
public string $emails;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $smtpEnabled = false;
|
|
|
|
#[Validate(['nullable', 'email'])]
|
|
public ?string $smtpFromAddress = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpFromName = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpRecipients = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpHost = null;
|
|
|
|
#[Validate(['nullable', 'numeric', 'min:1', 'max:65535'])]
|
|
public ?string $smtpPort = null;
|
|
|
|
#[Validate(['nullable', 'string', 'in:starttls,tls,none'])]
|
|
public ?string $smtpEncryption = 'starttls';
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpUsername = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpPassword = null;
|
|
|
|
#[Validate(['nullable', 'numeric'])]
|
|
public ?string $smtpTimeout = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $smtpEhloDomain = null;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $resendEnabled = false;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $resendApiKey = null;
|
|
|
|
#[Validate(['nullable', 'email'])]
|
|
public ?string $resendFromAddress = null;
|
|
|
|
#[Validate(['nullable', 'string'])]
|
|
public ?string $resendFromName = null;
|
|
|
|
#[Validate(['required', 'in:none,smtp,resend'])]
|
|
public string $emailProvider = 'none';
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $useInstanceEmailSettings = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $deploymentSuccessEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $deploymentFailureEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $deploymentCommitDetailsEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $statusChangeEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $restartLimitReachedEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $backupSuccessEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $backupFailureEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $scheduledTaskSuccessEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $scheduledTaskFailureEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $dockerCleanupSuccessEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $dockerCleanupFailureEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $serverDiskUsageEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $serverReachableEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $serverUnreachableEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $serverPatchEmailNotifications = false;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $traefikOutdatedEmailNotifications = true;
|
|
|
|
#[Validate(['boolean'])]
|
|
public bool $imageVulnerabilitiesEmailNotifications = true;
|
|
|
|
#[Validate(['nullable', 'email'])]
|
|
public ?string $testEmailAddress = null;
|
|
|
|
public function mount()
|
|
{
|
|
try {
|
|
$this->team = auth()->user()->currentTeam();
|
|
$this->emails = auth()->user()->email;
|
|
$this->settings = $this->team->emailNotificationSettings;
|
|
$this->authorize('view', $this->settings);
|
|
$this->syncData();
|
|
$this->testEmailAddress = auth()->user()->email;
|
|
} catch (\Throwable $e) {
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
private function syncData(bool $toModel = false): void
|
|
{
|
|
if ($toModel) {
|
|
$this->validate();
|
|
$this->validate(['smtpEhloDomain' => ['nullable', 'string', new ValidHostname]]);
|
|
if ($this->smtpHost !== $this->settings->smtp_host) {
|
|
$this->validate(['smtpHost' => ['nullable', 'string', new SafeSmtpHost]]);
|
|
}
|
|
$this->settings->smtp_enabled = $this->smtpEnabled;
|
|
$this->settings->smtp_recipients = $this->smtpRecipients;
|
|
$this->fillSmtpServerSettings();
|
|
|
|
$this->settings->resend_enabled = $this->resendEnabled;
|
|
$this->settings->resend_api_key = $this->resendApiKey;
|
|
$this->settings->resend_from_address = $this->resendFromAddress;
|
|
$this->settings->resend_from_name = $this->resendFromName;
|
|
|
|
$this->settings->use_instance_email_settings = $this->useInstanceEmailSettings;
|
|
|
|
$this->settings->deployment_success_email_notifications = $this->deploymentSuccessEmailNotifications;
|
|
$this->settings->deployment_failure_email_notifications = $this->deploymentFailureEmailNotifications;
|
|
$this->settings->deployment_commit_details_email_notifications = $this->deploymentCommitDetailsEmailNotifications;
|
|
$this->settings->status_change_email_notifications = $this->statusChangeEmailNotifications;
|
|
$this->settings->restart_limit_reached_email_notifications = $this->restartLimitReachedEmailNotifications;
|
|
$this->settings->backup_success_email_notifications = $this->backupSuccessEmailNotifications;
|
|
$this->settings->backup_failure_email_notifications = $this->backupFailureEmailNotifications;
|
|
$this->settings->scheduled_task_success_email_notifications = $this->scheduledTaskSuccessEmailNotifications;
|
|
$this->settings->scheduled_task_failure_email_notifications = $this->scheduledTaskFailureEmailNotifications;
|
|
$this->settings->docker_cleanup_success_email_notifications = $this->dockerCleanupSuccessEmailNotifications;
|
|
$this->settings->docker_cleanup_failure_email_notifications = $this->dockerCleanupFailureEmailNotifications;
|
|
$this->settings->server_disk_usage_email_notifications = $this->serverDiskUsageEmailNotifications;
|
|
$this->settings->server_reachable_email_notifications = $this->serverReachableEmailNotifications;
|
|
$this->settings->server_unreachable_email_notifications = $this->serverUnreachableEmailNotifications;
|
|
$this->settings->server_patch_email_notifications = $this->serverPatchEmailNotifications;
|
|
$this->settings->traefik_outdated_email_notifications = $this->traefikOutdatedEmailNotifications;
|
|
$this->settings->image_vulnerabilities_email_notifications = $this->imageVulnerabilitiesEmailNotifications;
|
|
$this->saveEmailSettings();
|
|
|
|
} else {
|
|
$this->smtpEnabled = $this->settings->smtp_enabled;
|
|
$this->smtpFromAddress = $this->settings->smtp_from_address;
|
|
$this->smtpFromName = $this->settings->smtp_from_name;
|
|
$this->smtpRecipients = $this->settings->smtp_recipients;
|
|
$this->smtpHost = $this->settings->smtp_host;
|
|
$this->smtpPort = $this->settings->smtp_port;
|
|
$this->smtpEncryption = $this->settings->smtp_encryption;
|
|
$this->smtpUsername = $this->settings->smtp_username;
|
|
$this->smtpPassword = auth()->user()->can('update', $this->settings)
|
|
? $this->settings->smtp_password
|
|
: null;
|
|
$this->smtpTimeout = $this->settings->smtp_timeout;
|
|
$this->smtpEhloDomain = $this->settings->smtp_ehlo_domain;
|
|
|
|
$this->resendEnabled = $this->settings->resend_enabled;
|
|
$this->resendFromAddress = $this->settings->resend_from_address;
|
|
$this->resendFromName = $this->settings->resend_from_name;
|
|
$this->resendApiKey = auth()->user()->can('update', $this->settings)
|
|
? $this->settings->resend_api_key
|
|
: null;
|
|
|
|
$this->smtpServerName = $this->settings->smtp_server_name;
|
|
$this->selectedSmtpServer = 'active';
|
|
|
|
$this->useInstanceEmailSettings = $this->settings->use_instance_email_settings;
|
|
$this->emailProvider = $this->activeEmailProvider();
|
|
|
|
$this->deploymentSuccessEmailNotifications = $this->settings->deployment_success_email_notifications;
|
|
$this->deploymentFailureEmailNotifications = $this->settings->deployment_failure_email_notifications;
|
|
$this->deploymentCommitDetailsEmailNotifications = $this->settings->deployment_commit_details_email_notifications;
|
|
$this->statusChangeEmailNotifications = $this->settings->status_change_email_notifications;
|
|
$this->restartLimitReachedEmailNotifications = $this->settings->restart_limit_reached_email_notifications;
|
|
$this->backupSuccessEmailNotifications = $this->settings->backup_success_email_notifications;
|
|
$this->backupFailureEmailNotifications = $this->settings->backup_failure_email_notifications;
|
|
$this->scheduledTaskSuccessEmailNotifications = $this->settings->scheduled_task_success_email_notifications;
|
|
$this->scheduledTaskFailureEmailNotifications = $this->settings->scheduled_task_failure_email_notifications;
|
|
$this->dockerCleanupSuccessEmailNotifications = $this->settings->docker_cleanup_success_email_notifications;
|
|
$this->dockerCleanupFailureEmailNotifications = $this->settings->docker_cleanup_failure_email_notifications;
|
|
$this->serverDiskUsageEmailNotifications = $this->settings->server_disk_usage_email_notifications;
|
|
$this->serverReachableEmailNotifications = $this->settings->server_reachable_email_notifications;
|
|
$this->serverUnreachableEmailNotifications = $this->settings->server_unreachable_email_notifications;
|
|
$this->serverPatchEmailNotifications = $this->settings->server_patch_email_notifications;
|
|
$this->traefikOutdatedEmailNotifications = $this->settings->traefik_outdated_email_notifications;
|
|
$this->imageVulnerabilitiesEmailNotifications = $this->settings->image_vulnerabilities_email_notifications;
|
|
}
|
|
}
|
|
|
|
public function submit()
|
|
{
|
|
try {
|
|
$this->resetErrorBag();
|
|
if (! $this->useInstanceEmailSettings) {
|
|
$this->enableSelectedEmailProvider();
|
|
}
|
|
$this->saveModel();
|
|
} catch (\Throwable $e) {
|
|
$this->restoreSavedEmailProvider();
|
|
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Turn on the provider selected in the provider list and save. When a required field of the
|
|
* provider is empty, nothing is saved and the page only shows the fields to fill in.
|
|
*/
|
|
public function selectEmailProvider()
|
|
{
|
|
try {
|
|
$this->enableSelectedEmailProvider();
|
|
} catch (ValidationException) {
|
|
// Not complete yet: show the fields of the provider and the "Not active yet" notice, without an error.
|
|
$this->resetErrorBag();
|
|
|
|
return null;
|
|
}
|
|
|
|
return $this->submit();
|
|
}
|
|
|
|
/**
|
|
* The provider that sends the team's email now. It differs from $emailProvider until the selected provider is saved.
|
|
*/
|
|
#[Computed]
|
|
public function activeEmailProvider(): string
|
|
{
|
|
return enabled_email_provider($this->settings) ?? 'none';
|
|
}
|
|
|
|
/**
|
|
* Turn on the provider selected in the provider list. When its settings are not valid, the saved
|
|
* provider stays on, so that a later save of another field cannot turn off the working provider.
|
|
*/
|
|
private function enableSelectedEmailProvider(): void
|
|
{
|
|
$this->smtpEnabled = $this->emailProvider === 'smtp';
|
|
$this->resendEnabled = $this->emailProvider === 'resend';
|
|
|
|
try {
|
|
$this->validateEnabledEmailProvider();
|
|
} catch (ValidationException $e) {
|
|
$this->restoreSavedEmailProvider();
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
private function restoreSavedEmailProvider(): void
|
|
{
|
|
$this->smtpEnabled = (bool) $this->settings->getOriginal('smtp_enabled');
|
|
$this->resendEnabled = (bool) $this->settings->getOriginal('resend_enabled');
|
|
}
|
|
|
|
private function validateEnabledEmailProvider(): void
|
|
{
|
|
match (true) {
|
|
$this->smtpEnabled => $this->validateSmtpSettings(),
|
|
$this->resendEnabled => $this->validateResendSettings(),
|
|
default => null,
|
|
};
|
|
}
|
|
|
|
public function saveModel()
|
|
{
|
|
$this->authorize('update', $this->settings);
|
|
|
|
$this->syncData(true);
|
|
$this->dispatch('success', 'Email notifications settings updated.');
|
|
}
|
|
|
|
public function instantSaveDeploymentCommitDetails()
|
|
{
|
|
try {
|
|
$this->resetErrorBag();
|
|
$this->saveModel();
|
|
} catch (\Throwable $e) {
|
|
$this->deploymentCommitDetailsEmailNotifications = $this->settings->deployment_commit_details_email_notifications;
|
|
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
public function instantSave(?string $type = null)
|
|
{
|
|
try {
|
|
$this->resetErrorBag();
|
|
|
|
if ($type === 'SMTP') {
|
|
$this->submitSmtp();
|
|
} elseif ($type === 'Resend') {
|
|
$this->submitResend();
|
|
} else {
|
|
$this->smtpEnabled = false;
|
|
$this->resendEnabled = false;
|
|
$this->saveModel();
|
|
|
|
return;
|
|
}
|
|
} catch (\Throwable $e) {
|
|
if ($type === 'SMTP') {
|
|
$this->smtpEnabled = false;
|
|
} elseif ($type === 'Resend') {
|
|
$this->resendEnabled = false;
|
|
}
|
|
|
|
return handleError($e, $this);
|
|
} finally {
|
|
$this->dispatch('refresh');
|
|
}
|
|
}
|
|
|
|
public function toggleSmtp()
|
|
{
|
|
try {
|
|
$this->resetErrorBag();
|
|
|
|
if ($this->smtpEnabled) {
|
|
$this->smtpEnabled = false;
|
|
$this->saveModel();
|
|
} else {
|
|
$this->validateSmtpSettings();
|
|
$this->smtpEnabled = true;
|
|
$this->submitSmtp();
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$this->syncData();
|
|
|
|
return handleError($e, $this);
|
|
} finally {
|
|
$this->dispatch('refresh');
|
|
}
|
|
}
|
|
|
|
public function toggleResend()
|
|
{
|
|
try {
|
|
$this->resetErrorBag();
|
|
|
|
if ($this->resendEnabled) {
|
|
$this->resendEnabled = false;
|
|
$this->saveModel();
|
|
} else {
|
|
$this->validateResendSettings();
|
|
$this->resendEnabled = true;
|
|
$this->submitResend();
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$this->syncData();
|
|
|
|
return handleError($e, $this);
|
|
} finally {
|
|
$this->dispatch('refresh');
|
|
}
|
|
}
|
|
|
|
public function submitSmtp()
|
|
{
|
|
$this->authorize('update', $this->settings);
|
|
|
|
try {
|
|
$this->resetErrorBag();
|
|
$this->validateSmtpSettings();
|
|
|
|
if ($this->smtpEnabled) {
|
|
$this->disableEmailProvidersExcept('smtp');
|
|
}
|
|
|
|
$this->settings->smtp_enabled = $this->smtpEnabled;
|
|
$this->fillSmtpServerSettings();
|
|
|
|
$this->saveEmailSettings();
|
|
$this->dispatch('success', 'SMTP settings updated.');
|
|
} catch (\Throwable $e) {
|
|
$this->smtpEnabled = false;
|
|
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
public function submitResend()
|
|
{
|
|
$this->authorize('update', $this->settings);
|
|
|
|
try {
|
|
$this->resetErrorBag();
|
|
$this->validateResendSettings();
|
|
if ($this->resendEnabled) {
|
|
$this->disableEmailProvidersExcept('resend');
|
|
}
|
|
|
|
$this->settings->resend_enabled = $this->resendEnabled;
|
|
$this->settings->resend_api_key = $this->resendApiKey;
|
|
$this->settings->resend_from_address = $this->resendFromAddress;
|
|
$this->settings->resend_from_name = $this->resendFromName;
|
|
|
|
$this->saveEmailSettings();
|
|
$this->dispatch('success', 'Resend settings updated.');
|
|
} catch (\Throwable $e) {
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Turn off every email provider except the given one, so only one provider sends email.
|
|
*/
|
|
private function disableEmailProvidersExcept(string $provider): void
|
|
{
|
|
if ($provider !== 'smtp') {
|
|
$this->settings->smtp_enabled = $this->smtpEnabled = false;
|
|
}
|
|
if ($provider !== 'resend') {
|
|
$this->settings->resend_enabled = $this->resendEnabled = false;
|
|
}
|
|
}
|
|
|
|
protected function loadEmailSettings(): void
|
|
{
|
|
$this->syncData();
|
|
}
|
|
|
|
private function validateSmtpSettings(): void
|
|
{
|
|
$this->validate([
|
|
'smtpEnabled' => 'boolean',
|
|
'smtpServerName' => 'nullable|string|max:255',
|
|
'smtpFromAddress' => 'required|email',
|
|
'smtpFromName' => 'required|string',
|
|
// A stored host is checked again at send time, so an unchanged host must not block saving other fields.
|
|
'smtpHost' => $this->smtpHost === $this->settings->smtp_host ? ['required', 'string'] : ['required', 'string', new SafeSmtpHost],
|
|
'smtpPort' => 'required|numeric',
|
|
'smtpEncryption' => 'required|string|in:starttls,tls,none',
|
|
'smtpUsername' => [Rule::requiredIf(SmtpPresets::requiresLogin($this->smtpHost)), 'nullable', 'string'],
|
|
'smtpPassword' => [Rule::requiredIf(SmtpPresets::requiresLogin($this->smtpHost)), 'nullable', 'required_with:smtpUsername', 'string'],
|
|
'smtpTimeout' => 'nullable|numeric',
|
|
'smtpEhloDomain' => ['nullable', 'string', new ValidHostname],
|
|
], [
|
|
'smtpFromAddress.required' => 'From Address is required.',
|
|
'smtpFromAddress.email' => 'Please enter a valid email address.',
|
|
'smtpFromName.required' => 'From Name is required.',
|
|
'smtpHost.required' => 'SMTP Host is required.',
|
|
'smtpPort.required' => 'SMTP Port is required.',
|
|
'smtpPort.numeric' => 'SMTP Port must be a number.',
|
|
'smtpUsername.required' => 'This provider needs a username.',
|
|
'smtpPassword.required' => 'This provider needs a password.',
|
|
'smtpPassword.required_with' => 'Enter the password for this username.',
|
|
'smtpEncryption.required' => 'Encryption type is required.',
|
|
]);
|
|
}
|
|
|
|
private function validateResendSettings(): void
|
|
{
|
|
$this->validate([
|
|
'resendEnabled' => 'boolean',
|
|
'resendApiKey' => $this->resendEnabled ? 'required|string' : 'nullable|string',
|
|
'resendFromAddress' => $this->resendEnabled ? 'required|email' : 'nullable|email',
|
|
'resendFromName' => $this->resendEnabled ? 'required|string' : 'nullable|string',
|
|
], [
|
|
'resendApiKey.required' => 'Resend API Key is required.',
|
|
'resendFromAddress.required' => 'From Address is required.',
|
|
'resendFromAddress.email' => 'Please enter a valid email address.',
|
|
'resendFromName.required' => 'From Name is required.',
|
|
]);
|
|
}
|
|
|
|
public function sendTestEmail()
|
|
{
|
|
try {
|
|
$this->authorize('sendTest', $this->settings);
|
|
$this->validate([
|
|
'testEmailAddress' => 'required|email',
|
|
], [
|
|
'testEmailAddress.required' => 'Test email address is required.',
|
|
'testEmailAddress.email' => 'Please enter a valid email address.',
|
|
]);
|
|
|
|
$executed = RateLimiter::attempt(
|
|
'test-email:'.$this->team->id,
|
|
$perMinute = 0,
|
|
function () {
|
|
$this->team?->notifyNow(new Test($this->testEmailAddress, 'email'));
|
|
$this->dispatch('success', 'Test Email sent.');
|
|
},
|
|
$decaySeconds = 10,
|
|
);
|
|
|
|
if (! $executed) {
|
|
throw new \Exception('Too many messages sent!');
|
|
}
|
|
} catch (\Throwable $e) {
|
|
return handleError($e, $this);
|
|
}
|
|
}
|
|
|
|
public function render()
|
|
{
|
|
return view('livewire.notifications.email');
|
|
}
|
|
|
|
/**
|
|
* Save the settings, record the changed field names (never secret values), and show the saved provider.
|
|
*/
|
|
protected function saveEmailSettings(): void
|
|
{
|
|
$changedFields = array_keys($this->settings->getDirty());
|
|
$this->settings->save();
|
|
$this->emailProvider = $this->activeEmailProvider();
|
|
|
|
if ($changedFields !== []) {
|
|
auditLog('ui.notifications.email.updated', [
|
|
'team_id' => $this->team->id,
|
|
'changed_fields' => array_values(array_diff($changedFields, ['smtp_password', 'resend_api_key'])),
|
|
]);
|
|
}
|
|
}
|
|
}
|