Membangun aplikasi Web dari awal dengan Laravel - Eloquent ORM

Dalam Nettuts + Mini Seri ini, kita akan membangun aplikasi web dari awal, sambil menyelam ke PHP framework baru yang keren, disebut Laravel.

Pada pelajaran ini kita akan bekerja pada bagian integral dari aplikasi web: Model. Sepanjang jalan, kita akan mempelajari tentang Laravel's menakjubkan ORM implementasi: Eloquent.

Tinjauan

Selamat datang kembali ke aplikasi Web kami dari awal dengan seri Laravel! Dalam tutorial pertama dari seri, kami belajar banyak tentang Laravel dan filosofi:

• Apakah itu Laravel
• Apa yang membuat Laravel berbeda dari Framework PHP lain
• Dimana untuk mendownload Laravel
• Cara men-setup Laravel
• Bagaimana Laravel's Routing sistem bekerja
• Sistem penjaluran beberapa fitur lainnya di Laravel
• Cara membuat Laravel Controller pertama
• Beberapa fitur tambahan dengan Laravel's controller
• Cara membuat tampilan Laravel pertama
• Bagaimana menggunakan Laravel's Blade Template Engine

Jika Anda belum membacanya Namun, Anda harus mengambil melihat tutorial sebelumnya dan memberikannya membaca - ini akan membuatnya lebih mudah untuk memahami filosofi di balik Laravel dan sebagian besar dari apa yang kita membahas dalam tutorial ini.

Dalam bagian kedua ini  dari seri Laravel, kami akan membangun bagian penting dari aplikasi tes web kami, Instapics, yang merupakan Model implementasi. Tanpa basa basi  lagi, mari kita mulai!

Apa itu "Model"?

Aku sudah bicara sedikit tentang apa Model itu di salah satu artikel saya sebelumnya, Zend Framework dari awal - model dan mengintegrasikan Doctrine ORM, jadi untuk menghindari mengulang sendiri, saya akan menulis inti dari apa yang saya tulis sebelumnya di sini. Jangan ragu untuk merujuk kepada tutorial lain dan membaca lebih lanjut tentang apa model yang ada.

Ringkasan:

• Model perwakilan dari Database, dan harus mana semua logika bisnis aplikasi berada
• Controller berkomunikasi dengan model dan meminta mereka untuk mengambil informasi yang mereka butuhkan
• Informasi ini kemudian melewati Controller ke tampilan dan dituliskan
• Sangat jarang bahwa Model langsung berinteraksi dengan View, tapi kadang-kadang mungkin terjadi bila diperlukan
• Model dapat berbicara dengan model-model lain dan tidak mandiri. Mereka memiliki hubungan yang terjalin dengan satu sama lain
• Hubungan ini membuatnya lebih mudah dan cepat untuk Controller untuk mendapatkan informasi, karena itu tidak berinteraksi dengan model - model yang dapat melakukan itu sendiri

Model Laravel, atau dalam kebanyakan framework, dikembangkan dengan cara yang sama. Perbedaannya adalah bahwa Laravel memberikan cara mudah untuk membangun model ini, dengan menyediakan kita dengan metode umum yang kebanyakan model akan perlu - Eloquent ORM.

Elqouent ORM

ORM adalah object-relational mapper, dan Laravel memiliki salah satu yang Anda absolutely will love! Dinamai "Eloquent," karena hal itu memungkinkan Anda untuk bekerja dengan objek database Anda dan hubungan menggunakan sintaks yang fasih dan ekspresif.

Eloquent ORM adalah Laravel's built-in ORM implementasi. Menurut pendapat saya, ini adalah salah satu implementasi ORM terbaik yang saya telah lihat sejauh ini - menyaingi bahkan Doctrine ORM. Itu sangat elegan, membuat penggunaan standar industri Konvensi untuk mengurangi konfigurasi.

Konvensi

Misalnya, menggunakan model Eloquent mengasumsikan bahwa memiliki tabel model yang mewakili field id. Id adalah kunci utama untuk redord, dan digunakan oleh sebagian besar metode Eloquent.

Hal lain juga Eloquent dengan benar mengasumsikan adalah bahwa nama tabel bentuk jamak model Anda. Sebagai contoh, model User Anda akan referensi tabel users. Seperti ini mungkin tidak selalu menjadi standar untuk beberapa, Laravel menyediakan cara untuk menimpa informasi ini: hanya menggunakan flag $table:

class User extends Eloquent {
    public static $table = 'my_users';
}

Ini akan menginstruksikan Laravel untuk tidak menggunakan Konvensi dan sebaliknya menggunakan tabel tertentu.

Akhirnya, Laravel juga dapat mengotomatisasi penciptaan dan memperbarui timestamp waktu bagi kita. Untuk melakukannya, tambahkan created_at dan/atau updated_at kolom dalam tabel, dan set $timestamp flag dalam model:

class User extends Eloquent {
    public static $timestamps = true;
}

Eloquent akan melihat flag, dan secara otomatis mengatur bidang created_at pada penciptaan, dan memperbarui field updated_at setiap kali record diupdate. Cukup keren, ya?

Pencarian cepat

Mengambil catatan adalah snap dengan Eloquent 's pengambilan metode. Misalnya, Anda perlu menemukan record pengguna tertentu? Hanya melakukan:

$user = User::find($user_id);

Ini akan mengembalikan model User yang dapat Anda lakukan operasi pada! Perlu menggunakan conditional? Mari kita bayangkan bahwa Anda ingin mengambil user dengan alamat email. Untuk menyelesaikan tugas ini, Anda mungkin melakukan sesuatu seperti:

$user = User::where('email', '=', $email)->first();

Atau, Anda dapat menggunakan Laravel's dinamis metode:

$user = User::where_email($email)->first();

Mudah menyisipkan & update

Memasukkan dan memperbarui model-model yang menggunakan Eloquent dapat dicapai dalam tiga langkah.

• Langkah 1 - Get/Create model.

          $user = new User();
          //or get an existing user
          $user = User::get($user_id);

• Langkah 2 - Set data

          $user->email = '[email protected]';
          $user->password = 'test1234';

• Langkah 3 - Simpan

          $user->save();

• Selesai!

Dan akhirnya, mendefinisikan Relationship.

Eloquent membuat proses mendefinisikan relationship dan mengambil model bersangkutan sederhana dan intuitif.

Benarkan! Eloquent mendukung tiga jenis hubungan:

1. One-to-One
2. One-to-Many
3. Many-to-Many

Untuk menentukan relationshop antara model-model, Anda akan perlu untuk menciptakan metode dalam kedua model yang "menggambarkan" hubungan mereka. Sebagai contoh, katakanlah User has_one User_Profile. Anda dapat melakukannya dengan mendefinisikan sebuah metode user_profile di User model:

class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one('User_Profile');
    }
}

Karena User adalah model "dominan" kami di sini (yaitu pengguna memiliki profil, dan memiliki tidak profil pengguna), kita mendefinisikan User_Profile belongs_to ke User:

class User_Profile extends Eloquent {
    public function user()
    {
        return $this->belongs_to('User');
    }
}

Setelah kita sudah didefinisikan relationship ini, kita kemudian dapat kita lakukan:

/*
  Get the User_Profile object of a User
  This executes two SQL queries:
  
  SELECT * FROM `users` WHERE `id` = $user_id
  SELECT * FROM `user_profiles` WHERE `user_id` = $user_id
*/
$user = User::find($user_id);
$user_profile = $user->user_profile;

/*
  We can also do it the other way around
*/
$user_profile = User_Profile::where('user_id', '=', $user_id)->first();
$user = $user_profile->user;

Satu hal yang perlu diperhatikan di sini adalah konvensi lainnya: Eloquent mengasumsikan bahwa foreign key yang digunakan dalam User_Profile adalah nama tabel direferensikan + _id. Sekali lagi, jika Anda ingin mengubah perilaku ini, Anda dapat mengganti itu:

class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one('User_Profile', 'user_profile_user_id');
    }
}

Mari kita mengatakan bahwa kita ingin menentukan relationship antara User dan Photo upload. Ini adalah Onte-to-Many relationship, tidak seperti User-to-User Profil  relationship dimana itu One-to-One Kita tahu bahwa salah satu User has_many Photo upload, jadi:

class User extends Eloquent {
    public function photos()
    {
        return $this->has_many('Photo');
    }
}
...
...
...
class Photo extends Eloquent {
    public function user()
    {
        return $this->belongs_to('User');
    }
}

Perbedaan utama dengan has_one adalah bahwa fungsi kita akan menggunakan untuk mengambil User foto sekarang akan mengembalikan sebuah array obyek Photo. Jadi, jika kita ingin mengambil semua User foto, kita bisa melakukan:

$photos = User::find($user_id)->photos;
foreach($photos as $photo) {
    ...
    ...
    ...
}

Nope, mengacu pada photos sebagai properti tidak salah ketik. Laravel memberi kita sedikit kemudahan. Kita juga bisa melakukan:

$photos = User::find($user_id)->photos()->get();

Many-to-Many Relationship

Satu ini agak sedikit rumit, tapi setelah diimplementasikan, membuatnya mudah untuk menangani Many-to-Many hubungan antara model-model. Mari kita bayangkan, misalnya, bahwa Anda, sekali lagi, memiliki User model, dan masing-masing pengguna dapat memiliki beberapa Groups. Group juga dapat memiliki beberapa user. Kami akan menggunakan tiga tabel untuk mewakili hubungan tertentu ini:

• Users - tabel dimana menyimpan user
• Groups - table yang mana semua grup disimpan
• Group User - tabel dimana menyimpan user di grup

Konvensi struktur tabel yang Eqloeunt akan mencari akan menjadi sesuatu seperti ini:

• users
  • id
  • .. .kolom lainnya
• groups
  • id
  • .. .kolom lainnya
• group_user
  • id
  • user_id
  • group_id
  • .. .kolom lainnya

Satu konvensi lainnya untuk dicatat di sini adalah bahwa tabel menengah, group_user, nama-nama singular dua tabel yang menghubungkan, disusun secara alfabetis dengan tanda garis bawah. Seperti biasa, kami akan bebas untuk menimpa informasi ini.

Berikut adalah bagaimana kode akan terlihat di dalam setiap model untuk tabel ini tiga:

class User extends Eloquent {
    public function groups()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to('Group', 'group_listings');
        
        return $this->has_many_and_belongs_to('Group');
    }
}
...
...
...
class Group extends Eloquent {
    public function users()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to('User', 'group_listings');
        
        return $this->has_many_and_belongs_to('User');
    }
}
...
...
...
class Group_User extends Eloquent {
    public function group()
    {
        return $this->has_one('Group');
    }
    
    public function user()
    {
        return $this->has_one('User');
    }
}

Dengan ini di tempat, kita kemudian dapat mengambil keuntungan dari Eloquent 's relationship fungsi:

//Get a user's groups
$groups = User::find($user_id)->groups;

//Get all users in a group
$users = Group::find($group_id)->users;

Langkah 1 - menciptakan Instapics Database

Melanjutkan dengan aplikasi web kami, Instapics, mari kita mulai dengan menciptakan database aplikasi kita. Untuk melakukannya, mari kita tuliskan fungsionalitas yang diinginkan dari aplikasi:

• Pengguna dapat login dan mendaftar untuk sebuah account
• Pengguna dapat mengikuti pengguna lain untuk melihat foto-foto yang mereka upload
• Pengguna dapat meng-upload foto mereka sendiri dan menerapkan penyaring untuk itu
• Pengguna dapat komentar dan like foto

Dari ini, kita dapat simpulkan tabel database yang kita perlukan:

• users
  • id (One-to-One dengan user_profiles.user_id, Many-to-Many dengan menggunakan diri intermediate tabel relationships.follower_id dan followed_id, One-to-Many dengan photos.user_id dan photo_comments.user_id)
  • email
  • sandi
  • created_at
  • updated_at
• user_profiles
  • id
  • user_id (One-to-One dengan users.id)
  • name
  • profile_photo
• relationship
  • id
  • follower_id(One-to-One dengan users.id)
  • followed_id (One-to-One dengan users.id)
  • created_at
  • updated_at
• photos
  • id (One-to-Many dengan photo_comments.user_id)
  • user_id (One-to-One dengan users.id)
  • location
  • description
  • created_at
  • updated_at
• photo_comments
  • id
  • user_id(One-to-One dengan users.id)
  • photo_id (One-to-One dengan photos.id)
  • message
  • created_at
  • updated_at

Mari kita pergi ke depan dan membuat tabel ini. Untuk proyek ini, aku akan menggunakan MySQL; merasa bebas untuk menyalin dan menyisipkan perintah ini.

CREATE DATABASE `instapics`;
USE `instapics`;

CREATE TABLE `instapics`.`users` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `email` VARCHAR(100) NOT NULL,
  `password` VARCHAR(100) NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_email`(`email`)
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`user_profiles` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `name` TEXT NOT NULL,
  `profile_photo` TEXT NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_user_id`(`user_id`),
  CONSTRAINT `FK_user_profiles_user_id` FOREIGN KEY `FK_user_profiles_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`relationships` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `follower_id` INTEGER UNSIGNED NOT NULL,
  `followed_id` INTEGER UNSIGNED NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_follower_id_followed_id`(`follower_id`, `followed_id`),
  CONSTRAINT `FK_relationships_follower_id` FOREIGN KEY `FK_relationships_follower_id` (`follower_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_relationships_followed_id` FOREIGN KEY `FK_relationships_followed_id` (`followed_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`photos` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `location` TEXT NOT NULL,
  `description` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photos_user_id` FOREIGN KEY `FK_photos_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE TABLE `instapics`.`photo_comments` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `photo_id` INTEGER UNSIGNED NOT NULL,
  `message` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photo_comments_user_id` FOREIGN KEY `FK_photo_comments_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_photo_comments_photo_id` FOREIGN KEY `FK_photo_comments_photo_id` (`photo_id`)
    REFERENCES `photos` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

Atau, Anda dapat menggunakan migration, tapi kami akan meninjau mereka dalam pelajaran nanti.

Langkah 2 - Setup Konfigurasi Database Laravel's

Sebelum melakukan apa-apa dengan model Laravel, kita perlu men-setup konfigurasi database kami instalasi Laravel. Buka application/config/database.php, untuk menemukan beberapa pengaturan ini:

• profile - pengaturan ini ke true akan log semua SQL querie kali ke log Laravel. Meninggalkan ini sebagai true untuk sekarang.
• fetch - jenis data yang dikembalikan dari PDO. Nilai default adalah PDO::FETCH_CLASS dan harus dibiarkan seperti.
• default - ini adalah nama pengaturan sambungan yang digunakan oleh aplikasi. Nama mengacu pada indeks dalam $connections array tepat di bawah
• connections - array asosiatif mungkin koneksi untuk aplikasi Anda.
  • driver - jenis server database. Ini bisa menjadi pgsql, sqlite, mysql atau sqlsrv
  • host - nama host dari server database Anda
  • database - nama database
  • username - username untuk menggunakan database server
  • password - password untuk digunakan pada database server
  • charset - charset untuk digunakan pada database server
  • prefiks - prefiks tabel di database, jika ada
• Redis - jika Anda berencana untuk menggunakan Laravel's Redis Perpustakaan, Anda dapat mengatur agar informasi server di sini.

Untuk tujuan dari tutorial ini, kita akan menggunakan MySQL. database.php file seharusnya terlihat seperti ini (saya dihapus komentar, tetapi mereka harus baik-baik saja untuk menjaga):

return array(
  'profile' => true,
	'fetch' => PDO::FETCH_CLASS,
	'default' => 'mysql',
	'connections' => array(
		'mysql' => array(
			'driver'   => 'mysql',
			'host'     => 'localhost',
			'database' => 'instapics',
			'username' => 'root',
			'password' => '(yourpassword)',
			'charset'  => 'utf8',
			'prefix'   => '',
		),
	),
	'redis' => array(
		'default' => array(
			'host'     => '127.0.0.1',
			'port'     => 6379,
			'database' => 0
		),
	)
);

Langkah 3 - membuat Model Laravel yang pertama Anda

Mulailah dengan membuat model Laravel di dalam folder application/modelsl. Membuat user.php di dalam, dan tambahkan kode berikut:

class User extends Eloquent {

}

Sekarang, berdasarkan review kami dari apa yang User relationshup, kita perlu kode metode relationship untuk mereka semua:

class User extends Eloquent {
    
    //setting $timestamp to true so Eloquent
    //will automatically set the created_at
    //and updated_at values
    public static $timestamps = true;
    
    public function user_profile()
    {
        return $this->has_one('User_Profile');
    }
    
    public function followers()
    {
        return $this->has_many_and_belongs_to('User', 'relationships', 'followed_id', 'follower_id');
    }
    
    public function following()
    {
        return $this->has_many_and_belongs_to('User', 'relationships', 'follower_id', 'followed_id');
    }
    
    public function photos()
    {
        return $this->has_many('Photo');
    }
    
    public function photo_comment()
    {
        return $this->has_many('Photo_Comment');
    }
}

Jelas, kita membuat penggunaan beberapa advanced many-tomany fungsi di sini, karena struktur tabel model pengikut kami (yaitu users Tabel referensi tabel relationship yang referensi users table lagi). Fungsi has_many_and_belongs_to memiliki tangan metode berikut:

/**
 * Get the query for a many-to-many relationship.
 *
 * @param  string        $model
 * @param  string        $table
 * @param  string        $foreign
 * @param  string        $other
 * @return Relationship
*/
public function has_many_and_belongs_to($model, $table = null, $foreign = null, $other = null)

Ini benar-benar Mari kita membuat model yang memiliki Many-to-Many relationship dengan dirinya sendiri (yaitu User mengikuti User lain). Kami menggunakan followers dan following metode berikut pada User model untuk memungkinkan kita untuk mendapatkan pengikut pengguna atau mendapatkan semua pengguna yang satu pengguna mengikuti, masing-masing.

Following User model, menciptakan model-model lain. Setelah Anda selesai, Anda harus:

• application/models/photo.php
• application/models/photo_comment.php
• application/models/relationship.php
• application/models/user.php
• application/models/user_profile.php

File-file ini akan dalam repositori Git tutorial, jadi jika Anda memilih untuk men-download mereka, Anda dapat menemukannya di sini: https://github.com/nikkobautista/laravel-tutorial

Langkah 4 - membuat fungsi pengguna untuk Instapics

Mari kita mulai menggunakan model kami dengan menciptakan beberapa fungsi pengguna kami akan memerlukan aplikasi. Pertama: pendaftaran pengguna. Dari tutorial sebelumnya, kami telah membuat formulir Registration/Login Form pada home page. Untuk sekarang, itu tidak melakukan apa-apa, tapi mari kita hook ke User controller, authenticate aksi. Membuat application/controllers/user.php dengan kode berikut:

class User_Controller extends Base_Controller
{    
    public function action_authenticate()
    {
        
    }
}

Buka application/views/home/index.blade.php dan mencari login form. Memperbarui formulir di baris 18 untuk kirim ke action_authenticate() metode:

<form class="well" method="POST" action="user/authenticate">

Kembali ke User_Controller, mari kita menempatkan beberapa kode dalam action_authenticate():

class User_Controller extends Base_Controller
{    
    public function action_authenticate()
    {
        $email = Input::get('email');
        $password = Input::get('password');
        $new_user = Input::get('new_user', 'off');
        
        if( $new_user == 'on' ) {
            try {
                $user = new User();
                $user->email = $email;
                $user->password = Hash::make($password);
                $user->save();
                Auth::login($user);
            
                return Redirect::to('dashboard/index');
            }  catch( Exception $e ) {
                echo "Faield to create new user!";
            }
        } else {
            $credentials = array(
                'username' => $email,
                'password' => $password
            );
            if( Auth::attempt($credentials)) {
                return Redirect::to('dashboard/index');
            } else {
                echo "Failed to login!";
            }
        }
    }
}

Mari kita break-down yang telah kami lakukan di sini sejauh ini:

• Kami menggunakan perpustakaan Input untuk mendapatkan masukan dari form yang disubmit
• Jika $new_user flag diperiksa, kami membuat User baru, menggunakan perpustakaan Hash untuk menghasilkan sandi yang dienkripsi.
• Login User baru dengan perpustakaan Auth
• Jika flag $new_user dicentang, kami menciptakan sebuah array $credentials, dan menggunakannya dengan perpustakaan Auth.
• Jika Auth::attempt benar, itu berarti kredensial yang benar dan kami masuk
• Lain, itu berarti kredensial yang salah.
• Dalam skenario kedua, mengarahkan ke Dashboard controller, index tindakan bila berhasil, dan echo pesan kegagalan jika tidak.

Perpustakaan Input

Fungsi dasar perpustakaan Input adalah untuk memungkinkan pengambilan data formulir. Sebagai contoh, di controller User, kami digunakan Input::get('email'); untuk mendapatkan nilai email dari bentuk. Hal ini penting untuk dicatat bahwa metode get digunakan untuk semua jenis permintaan dan bukan hanya $_GET array.

Anda dapat membaca lebih lanjut tentang Perpustakaan masukan di sini: http://laravel.com/docs/input#input

Auth Perpustakaan

Laravel dilengkapi dengan mekanisme otentikasi sendiri, Perpustakaan Auth. Dapat melakukan fitur berikut berkaitan dengan otentikasi pengguna.

Membuat hashed password

Kita dapat membuat penggunaan Perpustakaan Hash seperti:

$password = Hash::make($plaintext_password);

Metode ini menciptakan salted dan hashed sandi untuk user, menggunakan kunci enkripsi yang kita tetapkan di file konfigurasi. Untuk memeriksa jika hash benar, Anda dapat menggunakan:

if( Hash::check($plaintext_password, $hashed_password) == true ) {
    echo 'Password is correct.';
}

Logging user

Untuk ini, kita menggunakan metode attempt Auth Perpustakaan. Sebelum itu, meskipun, kami membangun sebuah array $credentials, yang merupakan array asosiatif dengan username dan password indeks:

$credentials = array(
    'username' => '[email protected]',
    'password' => 'yourpassword'
);
if( Auth::attempt($credentials) == true ) {
    echo 'User is logged in';
} else {
    echo 'Credentials failed';
}

Hal ini penting untuk menjaga dalam pikiran bahwa setelah upaya "sukses", pengguna secara otomatis masuk.

Loggin user in/out 

Kadang-kadang, kita akan perlu untuk login pengguna tanpa menggunakan metode attempt (seperti ketika log in pengguna dari link dalam email, atau pasca pendaftaran). Kita bisa melakukannya dengan metode Auth::login:

Auth::login($user); //where $user is a User object
Auth::login(42); //where 42 is the User's ID

Di sisi lain, kami juga memiliki Auth::logout metode untuk log user keluar:

Auth::logout();

Ini akan mengakhiri sesi pengguna.

Mengambil data pengguna login

Metode Auth::user yang memungkinkan kita untuk mengambil login di objek pengguna, serta informasi yang melekat padanya:

$email = Auth::user()->email;
$created_at = Auth::user()->created_at;

Mengkonfigurasi Auth Perpustakaan

Auth Perpustakaan harus dikonfigurasi sebelum menggunakannya (meskipun default akan bekerja dengan sebagian besar proyek, seperti yang satu ini). Variabel konfigurasi adalah:

• driver - ini bisa menjadi eloquent atau fluent. Pengembang dapat menulis driver sendiri dengan extend kelas Drive  di laravel/auth/driver.
• username - ini adalah nama kolom apa pun mewakili pengguna "username" dalam tabel database.
• model - ketika menggunakan Eloquent, ini adalah kelas model yang menggunakan perpustakaan Auth
• tabel - dengan menggunakan Fluent authentikasi driver, ini menentukan tabel database untuk pengguna dalam aplikasi

Proyek kami, Instapics, menggunakan nilai default di file konfigurasi auth.php, jadi kita tidak perlu untuk mengubah apa-apa di dalamnya.

Kembali ke proyek, mencoba menguji fitur login/registrasi Instapics! Cukup bagus, ya? Anda akan melihat meskipun bahwa kita tidak memiliki apa-apa di Dashboard controller belum, jadi mari kita bekerja pada berikutnya.

Langkah 5 - membuat Instapics Dashboard

Hal pertama yang perlu kita lakukan adalah membuat Dashboard controller, dengan index tindakan. Membuat file application/controllers/dashboard.php dan dimasukkan ke dalam kode berikut:

class Dashboard_Controller extends Base_Controller
{
    public function action_index()
    {
        $photos = Auth::user()->photos()->order_by('created_at', 'desc')->order_by('id', 'desc')->get();
        return View::make('dashboard.index', array('photos' => $photos));
    }
}

Sekarang kita perlu menciptakan halaman indeks Dashboard. Membuat application/views/dashboard/index.blade.php dan menambahkan berikut:

@layout('layouts/main')

@section('navigation')
@parent
<li><a href="user/logout">Logout</a></li>
@endsection

@section('content')
<div class="row">
    <div class="span3">
        <div class="well sidebar-nav">
            <ul class="nav nav-list">
                <li class="nav-header">Followers</li>
            </ul>
            <div style="margin-left: 10px">
                @forelse (Auth::user()->followers as $follower)
                    <div style="float: left; width: 30px; margin: 0px 3px 3px 5px;">
                        <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($follower->email))) }}?s=25&d=retro" alt="Follower" title="{{ $follower->email }}" />
                    </div>
                @empty
                    <div>You have no followers.</div>
                @endforelse
                <div style="clear: both"></div>
            </div>
            
            <ul class="nav nav-list">
                <li class="nav-header">Following</li>
            </ul>
            <div style="margin-left: 10px">
                @forelse (Auth::user()->following as $following)
                    <div style="float: left; width: 30px; margin: 0px 3px 3px 5px;">
                        <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($following->email))) }}?s=25&d=retro" alt="Following" title="{{ $following->email }}" />
                    </div>
                @empty
                    <div>You are not following anybody.</div>
                @endforelse
                <div style="clear: both"></div>
            </div>
        </div>
    </div>
    <div class="span9">
        <h1>Your Photos</h1>
        @forelse ($photos as $photo)
        <div class="well" style="text-align: center">
            <img src="http://nettuts.s3.amazonaws.com/2069_laravel_2/{{ $photo->location }}" alt="{{ $photo->description }}" title="{{ $photo->description }}" />
            <p>{{ $photo->description }}</p>
        </div>
        @empty
        <div class="alert alert-info">
            <h4 class="alert-heading">Awww!</h4>
            <p>Seems like you don't have any photos yet. <a href="#">Upload a new one?</a></p>
        </div>
        @endforelse
    </div>
</div>
@endsection

Refresh halaman dashboard, Anda harus melihat ini:

Terlihat sedikit kosong?. Menambahkan ini ke Dashboard controller, dan menjalankannya dengan mengakses dashboard/insert_test_data pada browser Anda:

public function action_insert_test_data()
{
    $logged_in_user = Auth::user();
    
    for( $x = 0; $x < 10; $x++ ) {
        $email = rand().'@gmail.com';
        $user = new User();
        $user->email = $email;
        $user->password = Hash::make($email);
        $user->save();
        
        $logged_in_user->followers()->attach($user->id);
        if( $x > 5 ) {
            $logged_in_user->following()->attach($user->id);
        }
    }
    
    $photos = array(
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg',
            'description' => 'Dusty Memories, The Girl in the Black Beret (http://www.flickr.com/photos/cloudy-day/)'
        ),
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm3.staticflickr.com/2354/2180198946_a7889e3d5c.jpg',
            'description' => 'Rascals, Tannenberg (http://www.flickr.com/photos/tannenberg/)'
        ),
        array(
            'user_id' => $logged_in_user->id,
            'location' => 'http://farm7.staticflickr.com/6139/5922361568_85628771cd.jpg',
            'description' => 'Sunset, Funset, Nikko Bautista (http://www.flickr.com/photos/nikkobautista/)'
        )
    );
    $logged_in_user->photos()->save($photos);
}

Ketika Anda memperbarui halaman, Anda akan melihat apa yang tampak seperti dengan data sampel dimasukkan:

Kesimpulan

Dalam bagian kedua dari seri Laravel kami, kita belajar:

• Beberapa latar belakang pada apa yang "Model"
• Apakah itu Eloquent ORM
• Cara mengatur konfigurasi database Laravel's
• Cara membuat Laravel Model yang pertama Anda
• Fungsi dasar dari perpustakaan Auth dan Input
• Membuat penggunaan ORM Eloquent dalam view

Eloquent benar-benar adalah sebuah implementasi ORM yang mengagumkan - cepat dan memiliki banyak fitur yang membuat interaksi database dalam aplikasi sesederhana mungkin.

Berikutnya di aplikasi Web kami dari awal dengan Laravel seri, kita akan mempelajari lebih lanjut tentang menggunakan Laravel's filter, Laravel's validasi library, dan bagaimana untuk bekerja dengan file dalam Laravel!

Apa pendapat Anda tentang Laravel's Eloquent ORM? Apakah itu sesuatu yang Anda anggap berguna? Beritahu saya di komentar! Dan, jika Anda anggota Tuts + Premium, menantikan untuk kursus Laravel Essentials yang akan datang dari kami!