Publication initiale de RelaisSMS : documentation et sources nettoyees

This commit is contained in:
2026-10-21 09:29:39 +02:00
commit ac186b03b1
158 changed files with 24818 additions and 0 deletions
@@ -0,0 +1,48 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\ValidationException;
use Illuminate\View\View;
class AuthenticatedSessionController extends Controller
{
public function create(): View
{
return view('auth.login');
}
public function store(Request $request): RedirectResponse
{
$credentials = $request->validate([
'email' => ['required', 'string', 'max:255'],
'password' => ['required', 'string'],
]);
$remember = $request->boolean('remember');
if (! Auth::attempt($credentials, $remember)) {
throw ValidationException::withMessages([
'email' => __('auth.failed'),
]);
}
$request->session()->regenerate();
return redirect()->intended(route('recipients.index', absolute: false));
}
public function destroy(Request $request): RedirectResponse
{
Auth::guard('web')->logout();
$request->session()->invalidate();
$request->session()->regenerateToken();
return redirect()->route('login');
}
}
@@ -0,0 +1,25 @@
<?php
namespace App\Http\Controllers;
use App\Services\CardDav\CardDavContactSyncService;
use Illuminate\Http\RedirectResponse;
use Throwable;
class CardDavSyncController extends Controller
{
public function __invoke(CardDavContactSyncService $syncService): RedirectResponse
{
try {
$run = $syncService->sync();
} catch (Throwable $exception) {
return redirect()
->route('contacts.index')
->with('status', 'Synchronisation CardDAV en echec : '.$exception->getMessage());
}
return redirect()
->route('contacts.index')
->with('status', $run->message ?? 'Synchronisation CardDAV terminee.');
}
}
+287
View File
@@ -0,0 +1,287 @@
<?php
namespace App\Http\Controllers;
use App\Contracts\PhoneNumberNormalizerInterface;
use App\Models\Contact;
use App\Models\ContactGroup;
use App\Models\SourceSyncRun;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
class ContactController extends Controller
{
public function index(Request $request): View
{
$search = (string) $request->query('q', '');
$groupId = $request->integer('group');
$favoriteOnly = $request->boolean('favorite');
$selectedStatus = (string) $request->query('status', '');
$selectedMobileFilter = (string) $request->query('mobile', 'detected');
if (! in_array($selectedStatus, ['', 'active', 'favorite', 'opt_out'], true)) {
$selectedStatus = '';
}
if (! in_array($selectedMobileFilter, ['all', 'detected', 'non_mobile', 'invalid', 'missing'], true)) {
$selectedMobileFilter = 'detected';
}
$contacts = Contact::query()
->with(['groups', 'phoneNumbers'])
->withCount('groups')
->search($search)
->when($groupId > 0, function ($query) use ($groupId): void {
$query->whereHas('groups', fn ($query) => $query->whereKey($groupId));
})
->when($favoriteOnly || $selectedStatus === 'favorite', function ($query): void {
$query->where('is_favorite', true);
})
->when($selectedStatus === 'opt_out', function ($query): void {
$query->where('sms_opt_out', true);
})
->when($selectedStatus === 'active', function ($query): void {
$query->where('sms_opt_out', false);
})
->when($selectedMobileFilter === 'detected', function ($query): void {
$query->whereHas('phoneNumbers', function ($query): void {
$query->where('is_valid', true)
->where(function ($query): void {
$query
->where('is_mobile', true)
->orWhere('normalized_number', 'like', '+336%')
->orWhere('normalized_number', 'like', '+337%');
});
});
})
->when($selectedMobileFilter === 'non_mobile', function ($query): void {
$query->whereHas('phoneNumbers', function ($query): void {
$query->where('is_valid', true)
->where('is_mobile', false)
->where('normalized_number', 'not like', '+336%')
->where('normalized_number', 'not like', '+337%');
});
})
->when($selectedMobileFilter === 'invalid', function ($query): void {
$query->whereHas('phoneNumbers', fn ($query) => $query->where('is_valid', false));
})
->when($selectedMobileFilter === 'missing', function ($query): void {
$query->whereDoesntHave('phoneNumbers');
})
->orderByDesc('is_favorite')
->orderBy('last_name')
->orderBy('first_name')
->paginate(15)
->withQueryString();
$groups = ContactGroup::query()
->withCount('contacts')
->orderBy('name')
->get();
return view('contacts.index', [
'contacts' => $contacts,
'groups' => $groups,
'search' => $search,
'selectedGroupId' => $groupId,
'favoriteOnly' => $favoriteOnly,
'selectedStatus' => $selectedStatus,
'selectedMobileFilter' => $selectedMobileFilter,
'cardDavSyncEnabled' => (bool) config('relais_sms.default_settings.carddav_sync_enabled'),
'lastCardDavSyncRun' => SourceSyncRun::query()
->where('source', 'carddav')
->latest('started_at')
->first(),
]);
}
public function create(): View
{
return view('contacts.create', [
'groups' => ContactGroup::query()->where('source', 'local')->orderBy('name')->get(),
]);
}
public function store(Request $request, PhoneNumberNormalizerInterface $normalizer): RedirectResponse
{
$validated = $request->validate($this->rules());
$contact = DB::transaction(function () use ($request, $validated, $normalizer): Contact {
$contact = Contact::query()->create([
'source' => 'local',
'first_name' => $validated['first_name'] ?? null,
'last_name' => $validated['last_name'],
'organization' => $validated['organization'] ?? null,
'email' => $validated['email'] ?? null,
'notes' => $validated['notes'] ?? null,
'sms_opt_out' => $request->boolean('sms_opt_out'),
'is_favorite' => $request->boolean('is_favorite'),
]);
$contact->groups()->sync($validated['group_ids'] ?? []);
$this->syncPrimaryPhoneNumber($contact, $validated, $normalizer);
return $contact;
});
return redirect()
->route('contacts.show', $contact)
->with('status', 'Contact cree.');
}
public function show(Contact $contact): View
{
$contact->load(['groups', 'phoneNumbers']);
return view('contacts.show', [
'contact' => $contact,
]);
}
public function favorite(Request $request, Contact $contact): RedirectResponse
{
$validated = $request->validate([
'is_favorite' => ['required', 'boolean'],
]);
$contact->update([
'is_favorite' => (bool) $validated['is_favorite'],
]);
return back()->with('status', $contact->is_favorite ? 'Contact ajoute aux favoris.' : 'Contact retire des favoris.');
}
public function optOut(Request $request, Contact $contact): RedirectResponse
{
$validated = $request->validate([
'sms_opt_out' => ['required', 'boolean'],
]);
$contact->update([
'sms_opt_out' => (bool) $validated['sms_opt_out'],
]);
return back()->with('status', $contact->sms_opt_out ? 'Contact ajoute aux refus SMS.' : 'Contact retire des refus SMS.');
}
public function edit(Contact $contact): View
{
$this->ensureLocalContact($contact);
$contact->load(['groups', 'phoneNumbers']);
return view('contacts.edit', [
'contact' => $contact,
'groups' => ContactGroup::query()->where('source', 'local')->orderBy('name')->get(),
'primaryPhone' => $contact->phoneNumbers->firstWhere('is_primary', true) ?? $contact->phoneNumbers->first(),
]);
}
public function update(Request $request, Contact $contact, PhoneNumberNormalizerInterface $normalizer): RedirectResponse
{
$this->ensureLocalContact($contact);
$validated = $request->validate($this->rules());
DB::transaction(function () use ($request, $contact, $validated, $normalizer): void {
$contact->update([
'first_name' => $validated['first_name'] ?? null,
'last_name' => $validated['last_name'],
'organization' => $validated['organization'] ?? null,
'email' => $validated['email'] ?? null,
'notes' => $validated['notes'] ?? null,
'sms_opt_out' => $request->boolean('sms_opt_out'),
'is_favorite' => $request->boolean('is_favorite'),
]);
$contact->groups()->sync($validated['group_ids'] ?? []);
$this->syncPrimaryPhoneNumber($contact, $validated, $normalizer);
});
return redirect()
->route('contacts.show', $contact)
->with('status', 'Contact modifie.');
}
public function destroy(Contact $contact): RedirectResponse
{
$this->ensureLocalContact($contact);
$contact->delete();
return redirect()
->route('contacts.index')
->with('status', 'Contact supprime.');
}
/**
* @return array<string, array<int, string>>
*/
private function rules(): array
{
return [
'first_name' => ['nullable', 'string', 'max:255'],
'last_name' => ['required', 'string', 'max:255'],
'organization' => ['nullable', 'string', 'max:255'],
'email' => ['nullable', 'email', 'max:255'],
'notes' => ['nullable', 'string'],
'phone_label' => ['nullable', 'string', 'max:255'],
'raw_phone_number' => ['nullable', 'string', 'max:255'],
'group_ids' => ['array'],
'group_ids.*' => [
'integer',
Rule::exists('contact_groups', 'id')
->where('source', 'local')
->whereNull('deleted_at'),
],
];
}
private function ensureLocalContact(Contact $contact): void
{
abort_if($contact->source !== 'local', 403, 'Les contacts importes ne sont pas modifiables localement.');
}
/**
* @param array<string, mixed> $validated
*/
private function syncPrimaryPhoneNumber(Contact $contact, array $validated, PhoneNumberNormalizerInterface $normalizer): void
{
$rawPhoneNumber = trim((string) ($validated['raw_phone_number'] ?? ''));
$primaryPhone = $contact->phoneNumbers()->where('is_primary', true)->first()
?? $contact->phoneNumbers()->first();
if ($rawPhoneNumber === '') {
$primaryPhone?->delete();
return;
}
$result = $normalizer->normalize(
$rawPhoneNumber,
(string) config('relais_sms.default_settings.default_country'),
);
$attributes = [
'label' => $validated['phone_label'] ?? null,
'raw_number' => $result->rawNumber,
'normalized_number' => $result->normalizedNumber,
'country' => $result->country,
'is_valid' => $result->isValid,
'is_mobile' => $result->isMobile,
'is_primary' => true,
'validation_error' => $result->error,
];
if ($primaryPhone) {
$primaryPhone->update($attributes);
return;
}
$contact->phoneNumbers()->create($attributes);
}
}
@@ -0,0 +1,117 @@
<?php
namespace App\Http\Controllers;
use App\Models\Contact;
use App\Models\ContactGroup;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
class ContactGroupController extends Controller
{
public function store(Request $request): RedirectResponse
{
$validated = $request->validate([
'name' => ['required', 'string', 'max:255', Rule::unique('contact_groups', 'name')->whereNull('deleted_at')],
'description' => ['nullable', 'string'],
]);
ContactGroup::query()->create([
'source' => 'local',
'name' => $validated['name'],
'slug' => $this->uniqueSlug($validated['name']),
'description' => $validated['description'] ?? null,
'is_favorite' => $request->boolean('is_favorite'),
]);
return redirect()
->route('contacts.index')
->with('status', 'Groupe cree.');
}
public function edit(ContactGroup $contactGroup): View
{
$this->ensureLocalGroup($contactGroup);
return view('contact-groups.edit', [
'group' => $contactGroup->load('contacts')->loadCount('contacts'),
'contacts' => Contact::query()
->with('phoneNumbers')
->orderBy('last_name')
->orderBy('first_name')
->get(),
'selectedContactIds' => $contactGroup->contacts->pluck('id')->all(),
]);
}
public function update(Request $request, ContactGroup $contactGroup): RedirectResponse
{
$this->ensureLocalGroup($contactGroup);
$validated = $request->validate([
'name' => [
'required',
'string',
'max:255',
Rule::unique('contact_groups', 'name')->ignore($contactGroup)->whereNull('deleted_at'),
],
'description' => ['nullable', 'string'],
'contact_ids' => ['array'],
'contact_ids.*' => [Rule::exists('contacts', 'id')->whereNull('deleted_at')],
]);
$contactGroup->update([
'name' => $validated['name'],
'slug' => $this->uniqueSlug($validated['name'], $contactGroup),
'description' => $validated['description'] ?? null,
'is_favorite' => $request->boolean('is_favorite'),
]);
if ($request->has('members_submitted')) {
$contactGroup->contacts()->sync($validated['contact_ids'] ?? []);
}
return redirect()
->route('contacts.index', ['group' => $contactGroup->id])
->with('status', 'Groupe modifie.');
}
public function destroy(ContactGroup $contactGroup): RedirectResponse
{
$this->ensureLocalGroup($contactGroup);
$contactGroup->contacts()->detach();
$contactGroup->delete();
return redirect()
->route('contacts.index')
->with('status', 'Groupe supprime.');
}
private function uniqueSlug(string $name, ?ContactGroup $ignore = null): string
{
$baseSlug = Str::slug($name);
$baseSlug = $baseSlug === '' ? 'groupe' : $baseSlug;
$slug = $baseSlug;
$index = 2;
while (ContactGroup::query()
->where('slug', $slug)
->when($ignore, fn ($query) => $query->whereKeyNot($ignore->id))
->exists()
) {
$slug = $baseSlug.'-'.$index;
$index++;
}
return $slug;
}
private function ensureLocalGroup(ContactGroup $contactGroup): void
{
abort_if($contactGroup->source !== 'local', 403, 'Les groupes importes ne sont pas modifiables localement.');
}
}
+8
View File
@@ -0,0 +1,8 @@
<?php
namespace App\Http\Controllers;
abstract class Controller
{
//
}
@@ -0,0 +1,83 @@
<?php
namespace App\Http\Controllers;
use App\Contracts\PhoneNumberNormalizerInterface;
use App\Models\ContactPhoneNumber;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class OvhStopCallbackController extends Controller
{
public function __invoke(Request $request, PhoneNumberNormalizerInterface $normalizer): JsonResponse
{
$configuredToken = trim((string) config('relais_sms.ovh.stop_callback_token', ''));
$receivedToken = trim((string) ($request->query('token') ?: $request->header('X-RelaisSMS-Callback-Token', '')));
abort_if($configuredToken === '' || ! hash_equals($configuredToken, $receivedToken), 403);
$sender = $this->sender($request);
if ($sender === '') {
return response()->json([
'status' => 'ignored',
'reason' => 'missing_sender',
], 422);
}
$result = $normalizer->normalize(
$sender,
(string) config('relais_sms.default_settings.default_country'),
);
if (! $result->isValid || $result->normalizedNumber === null) {
return response()->json([
'status' => 'ignored',
'reason' => 'invalid_sender',
], 422);
}
$contacts = ContactPhoneNumber::query()
->with('contact')
->where('normalized_number', $result->normalizedNumber)
->get()
->pluck('contact')
->filter()
->unique('id')
->values();
$updatedContacts = 0;
$alreadyOptedOutContacts = 0;
foreach ($contacts as $contact) {
if ($contact->sms_opt_out) {
$alreadyOptedOutContacts++;
continue;
}
$contact->update(['sms_opt_out' => true]);
$updatedContacts++;
}
return response()->json([
'status' => $contacts->isEmpty() ? 'unmatched' : 'ok',
'sender' => $result->normalizedNumber,
'updated_contacts' => $updatedContacts,
'already_opted_out_contacts' => $alreadyOptedOutContacts,
]);
}
private function sender(Request $request): string
{
foreach (['sender', 'from', 'number', 'phone', 'msisdn'] as $key) {
$value = $request->input($key);
if (is_string($value) && trim($value) !== '') {
return trim($value);
}
}
return '';
}
}
@@ -0,0 +1,186 @@
<?php
namespace App\Http\Controllers;
use App\Models\Contact;
use App\Models\ContactGroup;
use App\Services\Recipients\RecipientResolutionResult;
use App\Services\Recipients\RecipientResolver;
use App\Services\Sms\SmsMessageComposer;
use Illuminate\Contracts\View\View;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
class RecipientSelectionController extends Controller
{
public function index(Request $request, SmsMessageComposer $messageComposer): View
{
return $this->view($request, messageComposer: $messageComposer);
}
public function search(Request $request): JsonResponse
{
$search = trim((string) $request->query('q', ''));
$like = '%'.str_replace(['%', '_'], ['\%', '\_'], $search).'%';
$contacts = Contact::query()
->with('phoneNumbers')
->search($search)
->orderByDesc('is_favorite')
->orderBy('last_name')
->orderBy('first_name')
->limit(10)
->get()
->map(function (Contact $contact): array {
$primaryPhone = $contact->phoneNumbers->firstWhere('is_primary', true)
?? $contact->phoneNumbers->first();
return [
'type' => 'contact',
'id' => $contact->id,
'label' => $contact->displayName(),
'meta' => $primaryPhone?->normalized_number
?: $primaryPhone?->raw_number
?: $contact->email
?: ucfirst($contact->source),
'source' => $contact->source,
'is_favorite' => $contact->is_favorite,
];
});
$groups = ContactGroup::query()
->withCount('contacts')
->when($search !== '', function ($query) use ($like): void {
$query->where(function ($query) use ($like): void {
$query
->where('name', 'like', $like)
->orWhere('description', 'like', $like);
});
})
->orderByDesc('is_favorite')
->orderBy('name')
->limit(10)
->get()
->map(fn (ContactGroup $group): array => [
'type' => 'group',
'id' => $group->id,
'label' => $group->name,
'meta' => $group->contacts_count.' contact(s)',
'source' => $group->source,
'is_favorite' => $group->is_favorite,
]);
return response()->json([
'results' => $groups->concat($contacts)->values(),
]);
}
public function preview(Request $request, RecipientResolver $resolver, SmsMessageComposer $messageComposer): View|RedirectResponse
{
$validated = $request->validate([
'q' => ['nullable', 'string', 'max:255'],
'message' => ['nullable', 'string', 'max:612'],
'include_sms_header' => ['nullable', 'boolean'],
'include_sms_footer' => ['nullable', 'boolean'],
'contact_ids' => ['array'],
'contact_ids.*' => ['integer', Rule::exists('contacts', 'id')->whereNull('deleted_at')],
'group_ids' => ['array'],
'group_ids.*' => ['integer', Rule::exists('contact_groups', 'id')->whereNull('deleted_at')],
]);
$contactIds = $validated['contact_ids'] ?? [];
$groupIds = $validated['group_ids'] ?? [];
if ($contactIds === [] && $groupIds === []) {
return redirect()
->route('recipients.index', ['q' => $validated['q'] ?? null])
->withErrors(['selection' => 'Selectionnez au moins un contact ou un groupe.'])
->withInput();
}
return $this->view(
$request,
$resolver->resolve($contactIds, $groupIds),
$contactIds,
$groupIds,
$messageComposer,
);
}
/**
* @param array<int, int|string> $selectedContactIds
* @param array<int, int|string> $selectedGroupIds
*/
private function view(
Request $request,
?RecipientResolutionResult $resolution = null,
array $selectedContactIds = [],
array $selectedGroupIds = [],
?SmsMessageComposer $messageComposer = null,
): View {
$messageComposer ??= app(SmsMessageComposer::class);
$messageSettings = $messageComposer->settings();
$oldHeaderChoice = $request->old('include_sms_header');
$oldFooterChoice = $request->old('include_sms_footer');
$hasHeaderChoice = $oldHeaderChoice !== null || $request->has('include_sms_header');
$hasFooterChoice = $oldFooterChoice !== null || $request->has('include_sms_footer');
$includeHeader = $hasHeaderChoice
? filter_var($oldHeaderChoice ?? $request->input('include_sms_header'), FILTER_VALIDATE_BOOLEAN)
: $messageSettings['header'] !== '';
$includeFooter = $hasFooterChoice
? filter_var($oldFooterChoice ?? $request->input('include_sms_footer'), FILTER_VALIDATE_BOOLEAN)
: $messageSettings['footer'] !== '';
$messageBody = (string) $request->old('message', $request->input('message', ''));
$search = trim((string) $request->input('q', ''));
$like = '%'.str_replace(['%', '_'], ['\%', '\_'], $search).'%';
$contacts = Contact::query()
->with(['groups', 'phoneNumbers'])
->search($search)
->orderByDesc('is_favorite')
->orderBy('last_name')
->orderBy('first_name')
->limit(50)
->get();
$groups = ContactGroup::query()
->withCount('contacts')
->when($search !== '', function ($query) use ($like): void {
$query->where(function ($query) use ($like): void {
$query
->where('name', 'like', $like)
->orWhere('description', 'like', $like);
});
})
->orderByDesc('is_favorite')
->orderBy('name')
->limit(50)
->get();
return view('recipients.index', [
'contacts' => $contacts,
'groups' => $groups,
'search' => $search,
'selectedContactIds' => collect($selectedContactIds)->map(fn (int|string $id): int => (int) $id)->all(),
'selectedGroupIds' => collect($selectedGroupIds)->map(fn (int|string $id): int => (int) $id)->all(),
'selectedContacts' => Contact::query()
->whereKey($selectedContactIds)
->orderBy('last_name')
->orderBy('first_name')
->get(),
'selectedGroups' => ContactGroup::query()
->whereKey($selectedGroupIds)
->orderBy('name')
->get(),
'resolution' => $resolution,
'smsHeader' => $messageSettings['header'],
'smsFooter' => $messageSettings['footer'],
'includeSmsHeader' => $includeHeader,
'includeSmsFooter' => $includeFooter,
'composedMessage' => $messageComposer->compose($messageBody, $includeHeader, $includeFooter),
]);
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Http\Controllers;
use App\Models\AppSetting;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
class SettingsController extends Controller
{
public function edit(): View
{
return view('settings.edit', [
'smsHeader' => AppSetting::string('sms_message_header'),
'smsFooter' => AppSetting::string('sms_message_footer'),
]);
}
public function update(Request $request): RedirectResponse
{
$validated = $request->validate([
'sms_message_header' => ['nullable', 'string', 'max:612'],
'sms_message_footer' => ['nullable', 'string', 'max:612'],
]);
AppSetting::putString('sms_message_header', trim((string) ($validated['sms_message_header'] ?? '')));
AppSetting::putString('sms_message_footer', trim((string) ($validated['sms_message_footer'] ?? '')));
return redirect()
->route('settings.edit')
->with('status', 'Parametres enregistres.');
}
}
@@ -0,0 +1,287 @@
<?php
namespace App\Http\Controllers;
use App\Models\ContactGroup;
use App\Models\SmsCampaign;
use App\Models\User;
use App\Services\Recipients\RecipientResolver;
use App\Services\Sms\SmsCampaignSender;
use App\Services\Sms\SmsMessageComposer;
use Illuminate\Contracts\View\View;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Symfony\Component\HttpFoundation\StreamedResponse;
class SmsCampaignController extends Controller
{
private const STATUSES = [
'draft' => 'Brouillon',
'scheduled' => 'Programme',
'sending' => 'Envoi',
'uncertain' => 'A verifier',
'sent' => 'Envoye',
'partial' => 'Partiel',
'failed' => 'Echec',
'canceled' => 'Annule',
];
public function index(Request $request): View
{
$filters = $this->validateFilters($request);
return view('sms-campaigns.index', [
'campaigns' => $this->filteredCampaignsQuery($filters)
->latest()
->paginate(20)
->withQueryString(),
'filters' => $filters,
'groups' => ContactGroup::query()->orderBy('name')->get(['id', 'name']),
'statuses' => self::STATUSES,
'users' => User::query()->orderBy('name')->get(['id', 'name']),
]);
}
public function show(SmsCampaign $smsCampaign): View
{
return view('sms-campaigns.show', [
'campaign' => $smsCampaign->load(['deliveries' => fn ($query) => $query->orderBy('id'), 'user']),
]);
}
public function export(Request $request): StreamedResponse
{
$filters = $this->validateFilters($request);
$query = $this->filteredCampaignsQuery($filters)
->with(['deliveries' => fn ($query) => $query->orderBy('id')])
->latest();
return response()->streamDownload(function () use ($query): void {
$csv = fopen('php://output', 'w');
fputcsv($csv, [
'campagne_id',
'date_creation',
'date_programmee',
'date_envoi',
'utilisateur',
'statut_campagne',
'groupes_selectionnes',
'message',
'destinataires_prevus',
'destinataires_envoyes',
'destinataires_echoues',
'contact',
'numero',
'statut_destinataire',
'message_fournisseur_id',
'erreur',
], ';');
$query->chunk(100, function ($campaigns) use ($csv): void {
foreach ($campaigns as $campaign) {
foreach ($campaign->deliveries as $delivery) {
fputcsv($csv, [
$campaign->id,
$campaign->created_at->format('Y-m-d H:i:s'),
$campaign->scheduled_at?->format('Y-m-d H:i:s'),
$campaign->sent_at?->format('Y-m-d H:i:s'),
$campaign->user?->name ?: 'Utilisateur supprime',
self::STATUSES[$campaign->status] ?? $campaign->status,
implode(', ', $campaign->selected_group_names ?? []),
$campaign->message,
$campaign->recipients_count,
$campaign->sent_count,
$campaign->failed_count,
$delivery->contact_name,
$delivery->number,
$delivery->status,
$delivery->provider_message_id,
$delivery->error_message,
], ';');
}
}
});
}, 'historique-sms-'.now()->format('Ymd-His').'.csv', [
'Content-Type' => 'text/csv; charset=UTF-8',
]);
}
public function store(
Request $request,
RecipientResolver $resolver,
SmsCampaignSender $sender,
SmsMessageComposer $messageComposer,
): RedirectResponse {
$validated = $request->validate([
'message' => ['required', 'string', 'min:1', 'max:612'],
'include_sms_header' => ['nullable', 'boolean'],
'include_sms_footer' => ['nullable', 'boolean'],
'contact_ids' => ['array'],
'contact_ids.*' => ['integer', Rule::exists('contacts', 'id')->whereNull('deleted_at')],
'group_ids' => ['array'],
'group_ids.*' => ['integer', Rule::exists('contact_groups', 'id')->whereNull('deleted_at')],
'send_mode' => ['nullable', Rule::in(['now', 'scheduled'])],
'scheduled_at' => ['nullable', 'date'],
]);
$contactIds = $validated['contact_ids'] ?? [];
$groupIds = $validated['group_ids'] ?? [];
$resolution = $resolver->resolve($contactIds, $groupIds);
$recipients = $resolution->recipients;
$maxRecipients = (int) config('relais_sms.default_settings.max_sms_per_campaign', 100);
$messageSettings = $messageComposer->settings();
$message = $messageComposer->compose(
(string) $validated['message'],
$request->has('include_sms_header') ? $request->boolean('include_sms_header') : $messageSettings['header'] !== '',
$request->has('include_sms_footer') ? $request->boolean('include_sms_footer') : $messageSettings['footer'] !== '',
);
if ($recipients === []) {
return redirect()
->route('recipients.index')
->withErrors(['selection' => 'Aucun numero valide a envoyer.'])
->withInput();
}
if (mb_strlen($message) > 612) {
return redirect()
->route('recipients.index')
->withErrors(['message' => 'Le message complet avec entete et pied depasse 612 caracteres.'])
->withInput();
}
if (count($recipients) > $maxRecipients) {
return redirect()
->route('recipients.index')
->withErrors(['selection' => 'La selection depasse la limite de '.$maxRecipients.' SMS.'])
->withInput();
}
if (($validated['send_mode'] ?? 'now') === 'scheduled') {
if (! (bool) config('relais_sms.default_settings.scheduled_sends_enabled', true)) {
return redirect()
->route('recipients.index')
->withErrors(['scheduled_at' => 'Les envois programmes sont desactives.'])
->withInput();
}
if (($validated['scheduled_at'] ?? null) === null) {
return redirect()
->route('recipients.index')
->withErrors(['scheduled_at' => 'La date et l heure d envoi sont obligatoires pour programmer un SMS.'])
->withInput();
}
$scheduledAt = Carbon::parse((string) $validated['scheduled_at'], $this->scheduledTimezone())->utc();
if ($scheduledAt->lte(now())) {
return redirect()
->route('recipients.index')
->withErrors(['scheduled_at' => 'La date et l heure d envoi doivent etre futures.'])
->withInput();
}
$campaign = $sender->schedule($request->user(), $message, $recipients, $contactIds, $groupIds, $scheduledAt);
return redirect()
->route('sms-campaigns.show', $campaign)
->with('status', 'Campagne programmee pour le '.$campaign->scheduled_at?->timezone($this->scheduledTimezone())->format('d/m/Y H:i').'.');
}
$campaign = $sender->send($request->user(), $message, $recipients, $contactIds, $groupIds);
if ($campaign->status === 'uncertain') {
return redirect()->route('sms-campaigns.show', $campaign)->with('status', $campaign->error_message);
}
return redirect()
->route('sms-campaigns.show', $campaign)
->with(
$campaign->status === 'failed' ? 'error' : 'status',
$campaign->status === 'failed'
? 'Envoi refuse ou echoue : '.$campaign->error_message
: 'Campagne envoyee a '.$campaign->sent_count.' destinataire(s).',
);
}
public function cancel(SmsCampaign $smsCampaign): RedirectResponse
{
$canceled = DB::transaction(function () use ($smsCampaign): bool {
$campaign = SmsCampaign::query()
->whereKey($smsCampaign->id)
->lockForUpdate()
->first();
if (! $campaign || $campaign->status !== 'scheduled') {
return false;
}
$campaign->update([
'status' => 'canceled',
'canceled_at' => now(),
]);
$campaign->deliveries()
->where('status', 'queued')
->update(['status' => 'canceled']);
return true;
});
return redirect()
->route('sms-campaigns.show', $smsCampaign)
->with(
$canceled ? 'status' : 'error',
$canceled
? 'Campagne programmee annulee.'
: 'Cette campagne ne peut plus etre annulee.',
);
}
/**
* @return array{from?: string|null, to?: string|null, status?: string|null, user_id?: string|null, group_id?: string|null}
*/
private function validateFilters(Request $request): array
{
return $request->validate([
'from' => ['nullable', 'date'],
'to' => ['nullable', 'date'],
'status' => ['nullable', Rule::in(array_keys(self::STATUSES))],
'user_id' => ['nullable', 'integer', Rule::exists('users', 'id')],
'group_id' => ['nullable', 'integer', Rule::exists('contact_groups', 'id')->whereNull('deleted_at')],
]);
}
/**
* @param array{from?: string|null, to?: string|null, status?: string|null, user_id?: string|null, group_id?: string|null} $filters
* @return Builder<SmsCampaign>
*/
private function filteredCampaignsQuery(array $filters): Builder
{
return SmsCampaign::query()
->with('user')
->when($filters['from'] ?? null, fn (Builder $query, string $date): Builder => $query->whereDate('created_at', '>=', $date))
->when($filters['to'] ?? null, fn (Builder $query, string $date): Builder => $query->whereDate('created_at', '<=', $date))
->when($filters['status'] ?? null, fn (Builder $query, string $status): Builder => $query->where('status', $status))
->when($filters['user_id'] ?? null, fn (Builder $query, string $userId): Builder => $query->where('user_id', (int) $userId))
->when($filters['group_id'] ?? null, function (Builder $query, string $groupId): Builder {
$groupId = (int) $groupId;
return $query->where(function (Builder $query) use ($groupId): void {
$query
->whereJsonContains('selected_group_ids', $groupId)
->orWhereHas('deliveries.contact.groups', fn (Builder $query): Builder => $query->where('contact_groups.id', $groupId));
});
});
}
private function scheduledTimezone(): string
{
return (string) config('relais_sms.default_settings.display_timezone', 'Europe/Paris');
}
}