Author: Martin

Fast jede moderne Webanwendung besitzt ein Emailversand. Laravel macht es dem Entwickler hier sehr einfach.

In unserem Beispiel werden wir eine Bestellbestätigung an den Kunden senden. Als erstes erstellen wir einen Mail Anwendungsfall. In unserem Beispiel wird das eine Bestellbestätigung sein. Das machen wir über die Konsole:

php artisan make:mail OrderConfirmationMail -m emails.order_confirmation

Mit diesem Artisan Command erzeugt Laravel einen neuen Ordner “Mail” in unser Laravel Root Verzeichnis. Dort finden wird nun die Klasse OrderConfirmationMail und im View Order im Verzeichnis Emails (ressources/views/emails/order_confirmation.blade.php) das blade Template.

Weiter werden ich Euch zeigen, wie man die Mailausgabe erst mal zu Testzwecken im Browser sich anzeigen lässt. Es ginge natürlich hier auch sich die Mails alle an sein Postfach schicken zu lassen. Beides geht aber zum Entwickeln ist es schon besser die Mails vorerst im Browser ausgeben zu lassen. In Laravel ist das sehr simpel. Der Parameter -m beim artisan Command eben, ist der entscheidene Punkt um die Browserausgabe zu erzeugen. M steht für Markdown und erstellt in der OrderConfirmation Class in der Methode build() den Return Wert über die Markdown Funktion. Ansonsten würden wir die Laravel Fehlermeldung: “No hint path defined for [mail].” erhalten.

public function build()
{
      	// Also das wird mit -m generiert
	return $this→markdown('emails.order_confirmation');

	// ...und das ohne Markdown Parameter (-m)
       	return $this->view('emails.order_confirmation');
}

Es gibt hier zwei Varianten der Herangehensweise. Einmal über den Controller und die andere über den Router. Zuerst regeln wir es über den Router.

Erste Variante: Über den Router
Dafür gehen wir in unser Router web.php und fügen folgenden Code ein:

use App\Mail\OrderConfirmationMail;
...
Route::get(“/email”, function() {
	return new OrderConfirmationMail();
});
...

Im Browser können wir nun uns die Mail unter http://localhost:8080/email mal anzeigen lassen:

Aber wir wollen doch eine Email verschicken?

Klar, dass geht genauso leicht. Im Router modifizieren wir unser Route wie folgt:

Route::get(“/email”, function() {
	return new OrderConfirmationMail();
});

…und ergänzen unseren Bibliothekenimport noch mit:

use Illuminate\Support\Facades\Mail;

Die zweite Variante: Über den Controller

Sobald eine Bestellung eingegangen und in der Datenbank hinterlegt worden ist, soll an den Kunden eine Bestätigungsmail verschickt werden.

Im OrderController können wir in der store Methode mit folgende Zeilen den Mailversand antriggern:

return \Mail::to("hallo@meine.mail")        
->send(new OrderConfirmationMail());

Achtet hier bitte drauf das Ihr die OrderConfirmationMail für die OrderController verfügbar macht. Also:

use App\Mail\OrderConfirmationMail;

Theoretisch müsstet Ihr auch die Mail Facade reinholen. Aber wenn Ihr die Schreibweise: “\Mail::to(…“ wählt, ist sie somit auch verfügbar. Ansonsten: use Illuminate\Support\Facades\Mail; . Ist Geschmacksache oder Bequemlichkeit. Allerdings solltet Ihr einen Stil konsequent durchziehen und Sprünge vermeiden. Der Konsistenz halber.

Laravel Mail Kofiguration

Wichtig zu erwähnen ist, dass man bevor man eine Mail versendet, den Mailserver in Laravel richtig konfiguriert. Ich habe es über die .env datei vorgenommen und versende meine Mails über smtp.

MAIL_DRIVER=smtp
MAIL_HOST=mein.server.com
MAIL_PORT=25
MAIL_USERNAME=989123
MAIL_PASSWORD=password
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS=hallo@meinemail.de

Man kann nun auch im Controller bzw. Router beim Mail Klassen Aufruf Parameter übergeben und somit beim Aufruf einige Konfigurationen vornehmen. Zum Beispiel: CC, BCC hinzufügen.

Mails mit Daten füttern

Um jetzt personalisierte Mails zu versenden, können wir der Mailklasse einen Parameter mitgeben.

Im Controller

// Daten holen
$data = $this->getOrderDataFromDatabaseByOrderId($id);    

// Mail versenden    
return \Mail::to("hallo@meinemail.de")        
->send(new OrderConfirmationMail($data));

In der OrderMailClass

// in der methode build():
return $this->subject('Shop Bestellbestätigung')
→markdown('emails.order_confirmation');

// im Klassenkonstruktor
__constructor($data) {
	$this→data = $data;

Die neue Membervariable $this→data ist nun auch in der View mit $data ansprechbar. Wenn sie ein Array ist dann mit $data[“key”] oder falls es ein Objekt ist mit $data→key.

Gefühlt bei jedem neuen Webprojekt bzw. Apiprojekt bekommt man diesen Fehler und man reißt die Armen hoch zur Decke und ruft: “Warum immer ich? Wieso vergesse ich das immer wieder und was muss ich jetzt machen”. Wahrscheinlich ist es Euch eben so gerade passiert?

Als Autor dieses Textes sag ich: “Nicht schlimm. Passiert vielen und es ist ganz einfach”. Folge dieser Anleitung:

Schritt 1
Erstelle eine neue Middleware mit:

php artisan make:middleware Cors

Schritt 2
Gehe zur neuen Middleware und ändere den Rückgabewert der handle Methode wie folgt ab:

public function handle($request, Closure $next)
{
return $next($request)
	->header('Access-Control-Allow-Origin', "*")
	->header('Access-Controll-Allow-Methods', "GET, POST")
	->header('Access-Controll-Allow-Headers', "Accept,Authorization,Content-Type");
}

Schritt 3
Füge in der protected membervariablen $middleware in der Kernel.php die neuen Cors Middleware ein:

protected $middleware = [
	\App\Http\Middleware\TrustProxies::class,
	\Fruitcake\Cors\HandleCors::class,
	\App\Http\Middleware\CheckForMaintenanceMode::class,
	\Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
	\App\Http\Middleware\TrimStrings::class,
	\Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
	\App\Http\Middleware\Cors::class,
];

und das wars.

Erklärung

Die neu erstellte Middleware wird nun durch das Einhängen im Kernel bei jedem Request mit aufgerufen. Das bewirkt, dass der Response header mit den Header Attributen : Access-Control-Origin, -Methods und -Headers modifiziert mitgeschickt werden. Somit weiß der Clientbrowser: “keine Panik, alles im grünen Bereich. Der und wir dürfen das”.

Es ist wichtig zu verstehen, was das Konzept hinter einem Fremdschlüssel ist. Es ist kein Hexenwerk. Im Gegenteil es ist super simpel, aber manche wollen es nicht verstehen. Fremdschlüssel sind Bindeglieder zwischen Tabellen, die zeigen, dass die Daten zusammengehören obwohl sie in zwei unterschiedlichen Tabellen liegen.

Wir haben zwei Tabellen. Einmal eine Customers Tabelle (id, name, mail) und eine Orders Tabelle (id, customer_id, status). In beiden Tabellen soll die id ein Primärschlüssel sein. Ein Primärschlüssel ist einzigartig (unique) sowie kurz. Kurz weil es auch zusammengesetzte Primärschlüssel geben kann, die sehr lang werden können. Um das zu vermeiden, ist es am besten mit einem Integer der sich selbst inkrementiert zu arbeiten. Das ist quasi Standard.

Nun legen wir den Fremdschlüssel in Tabelle Orders auf customer_id. Somit wären die beiden Tabellen über die customer_id Verknüpft. Das erscheint auf dem ersten Blick als unnötig. Aber bei größeren Datenmengen oder komplexeren SQL Abfragen, wirkt sich der FK positiv und sehr erheblich auf die Abfragegeschwindigkeit aus.

Wie gehen wir in Laravel vor?

Als erstes legen wir die zwei Tabellen Customers und Orders an. Dazu bedien wir uns dem Laravel Komandozeilen Comand artisan.

php artisan make:migration create_customers_table
php artisan make:migration create_orders_table

Dann gehen wir zu den zwei neu angelegten Migrations PHP Dateien. Diese findest Du im Ordner: Database/Migrations. Die aktuelle Namenskovention der Migrationbs Dateien ist:

2020_06_10_114815_create_customers_table (YYYY_MM_DD_iiiiii_add_{name_name}_table)

In einer neu angelegten Migrations findest Du immer die zwei Methoden up und down. Hier die Customers.

...
public function up()
{
        Schema::create('customers', function (Blueprint $table) {
            #$table->id();
            $table->increments("id");            
            $table->string('name',20);
            $table->string('email',20);
}

public function down()
{
     Schema::dropIfExists('customers');
}

Nun legen wir eine neue Migrations Datei an. Und nennen diese ForeignKeys. Und statt create machen wir ein add.

php artisan make:migration add_foreign_keys_table

In dieser Datei fügen wir folgenden Code unter up() ein:

...
Schema::table('orders', function (Blueprint $table) {       
    $table->foreign('customer_id')->references('id')->on('customers');
});   
// und unter down() dann diesen Code:

Schema::table('orders', function (Blueprint $table) {            
     $table->dropForeign('orders_customer_id_foreign');                                                           
});

Was ist das up and down eigentlich?

Diese zwei Methoden werden von Laravel benötigt, wenn wir die Schemas in unsere Datenbank migrieren. Up dann für das bauen und down für das löschen, entfernen. Dazu bedienen wir uns dann wieder des artisan Commands:

php artisan migrate 
php artisan migrate:reset

Wichtig, falls es mal mit den Fremdschlüssel am Anfang nicht so klappt und ihr probleme habt die Tabellen unkompliziert zu löschen. Dafür gibt es den artisan befehl: wipe.

php artisan db:wipe

That it!