Membangun sebuah Panel Admin dengan Fule PHP Framework

Indonesian (Bahasa Indonesia) translation by Ari Gustiawan (you can also view the original English article)

Pada bagian pertama dari seri ini, kita melihat dasar-dasar framework FuelPHP. Pada bagian kedua ini, kita akan dapat menambah itu gigi dan pindah ke beberapa topik yang lebih maju! Kita akan menciptakan sebuah panel admin untuk aplikasi kita, meliputi penggunaan ORM dan menggunakan paket otentikasi untuk membatasi akses.

Bergabung dengan saya setelah istirahat untuk memulai!

Pengenalan

Karena artikel pertama Fuel telah diubah namanya menjadi FuelPHP. Juga tidak seperti artikel pertama yang didasarkan pada v1.0.1 artikel ini memerlukan v1.1.0 sehingga beberapa hal yang sedikit berbeda. Semua teori yang Anda telah belajar dari artikel pertama masih akurat dan tidak banyak yang berubah jadi ini harus menjadi mudah.

Langkah 1 - mengatur Oil

Jika Anda belum sudah menginstal utilitas command line oil dan cukup beruntung untuk berjalan pada Linux, Mac, Solaris, dll maka melakukannya dengan perintah berikut:

$ curl get.fuelphp.com/oil | sh

Langkah 2 - membuat sebuah aplikasi baru

Perintah oil akan membantu Anda membuat proyek baru dengan beberapa kunci-stroke dan alias php oil ketika di dalam aplikasi FuelPHP Anda:

$ oil create Sites/blog
$ cd Sites/blog

Ini akan mengatur aplikasi blog untuk kita dan dengan asumsi Anda memiliki Apache atau beberapa server web lain yang berjalan pada folder "Sites" Anda harus dapat memuat URL berikut dan melihat halaman Selamat datang.

Sekarang FuelPHP hidup dan server web Anda jelas bekerja, kita dapat memulai konfigurasi aplikasi kami.

Langkah 3 - konfigurasi aplikasi Anda

Membuka editor favorit Anda dan kami akan mulai dengan menyiapkan koneksi database dan mengkonfigurasi aplikasi. Ini hampir identik dengan v1.0.x, sehingga membuat database dan mengatur pengguna SQLseperti biasanya anda lakukan. Ketika datang ke konfigurasi database ada dua perbedaan:

PDO adalah sekarang driver default
FuelPHP v1.1 memiliki konfigurasi environment-based folder sekarang.

Perubahan cukup sederhana, tetapi Anda dapat swap kembali ke menggunakan drive MySQL native jika Anda suka. PDO lebih berguna bagi pengembang seperti itu berarti bahwa aplikasi Anda akan bekerja dengan hampir semua database engine tidak hanya beberapa yang telah FuelPHP khusus driver yang dibangun untuk mereka. Itu berarti ini bisa sama seperti dengan mudah menjadi SQLite atau PostgreSQL.

Hanya membuka fuel/app/config/development/db.php dan mengubah konfigurasi Anda, mana dbname = blog adalah apa yang disebut database Anda dan Anda sendiri username dan password untuk database server:

return array(
  'default' => array(
    'connection'  => array(
 		 'dsn'  	=> 'mysql:host=localhost;dbname=blog',
 		 'username' => 'root',
 		 'password' => 'password',
 	 ),
  ),
);

Selanjutnya Anda akan perlu untuk membuka fuel/app/config/config.php dan mengaktifkan paket auth dan orm seperti yang disarankan dalam posting pertama.

/**************************************************************************/
/* Always Load                    */
/**************************************************************************/
'always_load'  => array(

	'packages'  => array(
		'auth', 
'orm',
	),

Dalam file konfigurasi ini, kita perlu membuat satu perubahan kecil ke array whitelisted_classes yang akan memungkinkan kita untuk memvalidasi objek ke view:

	'whitelisted_classes' => array(
		'Fuel\\Core\\Response',
		'Fuel\\Core\\View',
		'Fuel\\Core\\ViewModel',
		'Fuel\Core\Validation',
		'Closure',
	),

Pengaturan grup

Auth paket disertakan dengan FuelPHP adalah driver berbasis dan secara default kita menggunakan "SimpleAuth" driver yang hanya ada dalam paket. Ketika Anda lebih berpengalaman dengan FuelPHP, Anda dapat mulai untuk membuat custom driver untuk mengintegrasikan dengan sistem pengguna lain - seperti pihak ketiga forum, sistem manajemen konten, dll.

Untuk mengaktifkan grup untuk SimpleAuth, kami cukup membuka fuel/packages/auth/config/simpleauth.php dan mengatur grup berikut:

return array(
  'groups' => array(
 	  -1 => array('name' => 'Banned', 'roles' => array('banned')),
 	  0	=> array('name' => 'Guests', 'roles' => array()),
 	  1	=> array('name' => 'Users', 'roles' => array('user')),
 	  50 => array('name' => 'Moderators', 'roles' => array('user', 'moderator')),
 	  100  => array('name' => 'Administrators', 'roles' => array('user', 'moderator', 'admin')),
  ),
);

Ini, tentu saja, bisa apa-apa, tapi cukup standar untuk kebanyakan aplikasi dan akan bekerja untuk tutorial ini.

Langkah 4 - membuat pengguna

Seperti kita sedang membangun sebuah panel admin, kita perlu membuat tabel pengguna dan kemudian mengisi dengan record pengguna yang akan menjadi administrator pertama. Kita bisa menggunakan sesuatu seperti phpMyAdmin atau GUI seperti Navicat, tetapi lebih baik untuk melakukan hal-hal melalui Oil jadi kita tetap dalam basis kode kami. Ini berarti password hashing adalah sudah di salt dengan benar dengan driver apa pun yang digunakan - dan adalah bagaimana kita akan melakukan ini:

$ oil generate model users username:varchar[50] password:string group:int email:string last_login:int login_hash:string profile_fields:text
  Creating model: /Users/phil/Sites/blog/fuel/app/classes/model/user.php
  Creating migration: /Users/phil/Sites/blog/fuel/app/migrations/001_create_users.php
$ oil refine migrate

Ini menciptakan user model untuk kita dan menciptakan migrasi lain yang akan membangun tabel user kami ketika memperbaiki oil bermigrasi tugas dijalankan. Berikutnya kita harus menciptakan Administrator user, yang, sekali lagi, kita bisa melakukan melalui GUI tapi mana yang menyenangkan itu?

$ oil console
Fuel 1.1-rc1 - PHP 5.3.6 (cli) (Sep  8 2011 19:31:33) [Darwin]
>>> Auth::create_user('admin', 'password', '[email protected]', 100);
1
-- Ctrl + C to exit

Kami telah menggunakan Oil konsol untuk menulis kode secara real-time dan mendapat jawaban. Auth::create_user() dimasukan username, password, alamat email dan group_id untuk admin, yang sekarang kita hanya akan menggunakan 100 - yang kita tentukan dalam konfigurasi. 1 adalah respon dari kode, yang berarti user_id memiliki nilai 1.

Langkah 5 - kode generasi

Generator adalah cara yang bagus untuk membangun banyak kode dari awal dan memulai.

Seperti dijelaskan dalam artikel pertama kita dapat menggunakan scaffolding untuk membangun potongan besar aplikasi dengan cepat. Ini dilakukan melalui perintah oil dan semua sangat opsional, tetapi ini adalah cara yang bagus untuk membangun banyak kode dari awal. Beberapa orang melihat kode generasi sebagai "tool untuk orang-orang yang tidak tahu bagaimana membuat kode" atau yang semacam sihir hitam, tetapi jika Anda baru di framework dan tidak mau harus belajar bagaimana untuk menempatkan semuanya bersama-sama maka memiliki sistem yang membuat kode untuk Anda tidak berpikir seperti hal yang buruk.

FuelPHP v1.1 mengambil kode generasi satu langkah kecil lebih lanjut. Bukan hanya membuat scaffolding (unprotected CRUD) Anda bisa menghasilkan Admin kode. Ini bekerja dalam cara yang sama tetapi menerapkan template admin sederhana, admin controller, dll dan menggunakan paket auth untuk mengunci kode yang dihasilkan. Mengambil keuntungan dari Bootstrap Twitter, ini semua terlihat cukup baik untuk digunakan dan dengan hanya sedikit mengutak-atik Anda akan memiliki sebuah aplikasi yang Anda dapat dipakai.

Hal ini dilakukan melalui baris perintah menggunakan perintah oil. Kita akan menghasilkan beberapa kode lalu berjalan melalui itu.

$ oil generate admin posts title:string slug:string summary:text body:text user_id:int
	Creating controller: /Users/phil/Sites/blog/fuel/app/classes/controller/base.php
	Creating controller: /Users/phil/Sites/blog/fuel/app/classes/controller/admin.php
	Creating views: /Users/phil/Sites/blog/fuel/app/views/admin/template.php
	Creating views: /Users/phil/Sites/blog/fuel/app/views/admin/dashboard.php
	Creating views: /Users/phil/Sites/blog/fuel/app/views/admin/login.php
	Creating migration: /Users/phil/Sites/blog/fuel/app/migrations/002_create_posts.php
	Creating model: /Users/phil/Sites/blog/fuel/app/classes/model/post.php
	Creating controller: /Users/phil/Sites/blog/fuel/app/classes/controller/admin/posts.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/posts/index.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/posts/view.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/posts/create.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/posts/edit.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/posts/_form.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/template.php

Ini adalah sedikit kode karena itu adalah pertama kalinya dijalankan. FuelPHP akan mengatur beberapa dasar template dan file, kemudian membangun komponen MVC untuk bagian post. Ingat, ini adalah seperti menulis kode diri sendiri, tapi lebih cepat. Anda dapat mengambil melihat output ini dengan pergi ke /blog/public/admin/posts:

Memahami controller

Kami telah menambahkan Controller_Base yang akan berisi logika untuk seluruh aplikasi Anda, sehingga setiap controller dapat extend dari ini. File hanya berisi:

abstract class Controller_Base extends Controller_Template {

	public function before()
	{
		parent::before();
		
		// Assign current_user to the instance so controllers can use it
		$this->current_user = Auth::check() ? Model_User::find(Arr::get(Auth::get_user_id(), 1)) : null;
		
		// Set a global variable so views can use it
		View::set_global('current_user', $this->current_user);
	}

}

Dengan extend Controller_Template, Semua view akan dibungkus oleh template secara otomatis. Maka dalam fungsi before() kita melakukan sedikit logika untuk mendapatkan pengguna saat ini dan membuatnya tersedia sebagai $this-> current_user di controller dan $current_user di view.

Controller lain akan dibangun disebut Controller_Admin yang extend Controller_Base, begitu juga memiliki pengguna saat ini sedang dibangun kita dapat memeriksa untuk melihat apakah pengguna benar-benar admin:

abstract class Controller_Admin extends Controller_Base {

	public $template = 'admin/template';

	public function before()
	{
		parent::before();

		if ( ! Auth::member(100) and Request::active()->action != 'login')
		{
			Response::redirect('admin/login');
		}
	}

	// ....
		
}

Anda akan melihat bahwa controller ini set template kustom daripada mencari di fuel/app/views/template.php, ia akan mencari fuel/app/views/admin/template.php. Kemudian jika pengguna tidak cocok member(100) - admin ID grup yang ditetapkan sebelumnya - mereka akan dikirim halaman login.

Extend controller

Salah satu fitur yang sangat berguna yang FuelPHP adalah untuk memungkinkan Anda untuk memperluas controller lainnya. Biasanya mereka hanya dimuat secara langsung oleh kelas permintaan setelah dirutekan ke oleh URL, tapi kadang-kadang hal ini berguna untuk memperpanjang controller untuk berbagi logika atau metode. Dalam kasus ini, kita yang sudah memeriksa izin di Controller_Admin sehingga kita dapat extend itu controller untuk menggunakan kembali logika ini.

Controller_Admin_Posts extend Controller_Admin. Ini berarti itu before() check sama dan oleh karena itu dilindungi dalam cara yang sama seperti kontroler lain dalam panel admin Anda.

Sekarang apa?

Kode generasi pada dasarnya adalah langkah pertama dalam bekerja pada sebuah aplikasi. Kita masih perlu untuk men-tweak form kami dan membuat frontend. Misalnya, jika Anda pergi untuk membuat atau mengedit postinpost ini akan menunjukkan bidang user_id sebagai text box.

Langkah 6 - memperbarui form CRUD

Kita akan ingin memodifikasi metode action_create() dalam fuel/app/classes/admin/posts.php sehingga kita punya daftar pengguna yang tersedia. Untuk melakukan hal ini kita dapat mengganti metode dengan kode ini:

public function action_create($id = null)
{
	$view = View::forge('admin/posts/create');

	if (Input::method() == 'POST')
	{
		$post = Model_Post::forge(array(
			'title' => Input::post('title'),
			'slug' => Inflector::friendly_title(Input::post('title'), '-', true),
			'summary' => Input::post('summary'),
			'body' => Input::post('body'),
			'user_id' => Input::post('user_id'),
		));

		if ($post and $post->save())
		{
			Session::set_flash('success', 'Added post #'.$post->id.'.');
			Response::redirect('admin/posts');
		}

		else
		{
			Session::set_flash('error', 'Could not save post.');
		}
	}

	// Set some data
	$view->set_global('users', Arr::assoc_to_keyval(Model_User::find('all'), 'id', 'username'));

	$this->template->title = "Create Post";
	$this->template->content = $view;
}

Ini adalah sama dengan kode sebelum dengan dua perubahan:

$view = View::forge('admin/posts/create');

Hal ini menciptakan objek View baru. Kami dapat menetapkan properti view ini dengan menetapkan mereka sebagai properti, sehingga data pengguna kami dapat memasukan dengan mudah dan biasanya akan bekerja sedikit seperti ini:

$view->users = array(1 => "User 1", 2 => "User 2");

Sekarang kita membuat sebuah update serupa untuk action_edit():

public function action_edit($id = null)
{
	$view = View::forge('admin/posts/edit');
	
	$post = Model_Post::find($id);

	if (Input::method() == 'POST')
	{
		$post->title = Input::post('title');
		$post->slug = Inflector::friendly_title(Input::post('title'), '-', true);
		$post->summary = Input::post('summary');
		$post->body = Input::post('body');
		$post->user_id = Input::post('user_id');

		if ($post->save())
		{
			Session::set_flash('success', 'Updated post #' . $id);
			Response::redirect('admin/posts');
		}

		else
		{
			Session::set_flash('error', 'Could not update post #' . $id);
		}
	}

	else
	{
		$this->template->set_global('post', $post, false);
	}
	
	// Set some data
	$view->set_global('users', Arr::assoc_to_keyval(Model_User::find('all'), 'id', 'username'));

	$this->template->title = "Edit Post";
	$this->template->content = $view;
}

Namun, karena view create.php dan edit.php berbagi tema _form.php parsial, dan properti hanya menetapkan variabel tertentu satu view kita perlu menggunakan metode View:: set_global():

$view->set\_global('users', Arr::assoc_to_keyval(Model\_User::find('all'), 'id', 'username'));

Ini menggunakan Model_User objek untuk mendapatkan semua pengguna kami, kemudian merata mereka untuk array asosiatif untuk form.

HTML sekarang perlu berubah, sehingga menghapus div pembungkus "slug" - kita akan lakukan itu sendiri dan mengubah bidang user_id dari menjadi input box ke select box:

<div class="clearfix">
	<?php echo Form::label('User', 'user_id'); ?>

	<div class="input">
		<?php echo Form::select('user_id', Input::post('user_id', isset($post) ? $post->user_id : $current_user->id), $users, array('class' => 'span6')); ?>

	</div>
</div>

Ini akan mengatur kotak untuk menunjukkan semua pengguna dan default untuk saat ini login pengguna jika tidak diberikan. Itulah tweak hanya kita perlu membuat pada titik ini, jadi mari kita membuat frontend!

Frontend

Membuat blog dasar frontend benar-benar sederhana sehingga tidak akan khawatir tentang menggunakan kode generasi.

Buat controller fuel/app/classes/controller/blog.php baru:

class Controller_Blog extends Controller_Base
{
	public function action_index()
	{
		$view = View::forge('blog/index');
		
		$view->posts = Model_Post::find('all');
		
		$this->template->title = 'My Blog about Stuff';
		$this->template->content = $view;
	}
}

Dan file view fuel/app/views/blog/index.php:

<h2>Recent Posts</h2>

<?php foreach ($posts as $post): ?>

	<h3><?php echo Html::anchor('blog/view/'.$post->slug, $post->title) ?></h3>
	
	<p><?php echo $post->summary ?></p>

<?php endforeach; ?>

Ini adalah hanya loop sederhana melalui $posts array yang berisi semua artikel Anda.

Foreach loop, hyperlink dan ringkasan adalah semua yang kita butuhkan pada file view ini dan kami akan membuat file tampilan lain untuk benar-benar melihat post. Kami akan memanggil ini action_view() metode controller dan membuat file tampilan yang disebut view.php:

<h2><?php echo $post->title ?></h2>

<p><strong>Posted: </strong><?php echo date('nS F, Y', $post->created_at) ?> (<?php echo Date::time_ago($post->created_at)?>)</p>

<p><?php echo nl2br($post->body) ?></p>

Ini adalah metode untuk blog controller:

public function action_view($slug)
{
	$post = Model_Post::find_by_slug($slug);
	
	$this->template->title = $post->title;
	$this->template->content = View::forge('blog/view', array(
		'post' => $post,
	));
}

Metode find_by_slug() adalah "magic method" yang akan membangun WHERE slug = "foo" kueri Anda dan mengembalikan satu Model_Post dengan data tersebut.

Sekarang orang dapat melihat website Anda - mengerikan unstyled - dan melihat blog dasar, dan Anda memiliki antarmuka admin untuk mengelola itu!

Langkah 7 - menggunakan ORM

Sejauh ini kita telah menggunakan ORM untuk model kami lakukan CRUD dasar tapi kita belum melihat ada hubungannya dengan hubungan. ORM membuat ini sangat mudah seperti, baik berdiri untuk "Objek Relational Mapping" karena suatu alasan. Untuk mengatur hubungan yang perlu kita lakukan adalah mengubah model kami sedikit untuk menjelaskan bagaimana ORM harus berhubungan data.

Post yang dibuat oleh satu pengguna, jadi kita katakan "dimiliki" pengguna. Di Model_Post kita dapat menambahkan:

protected static $_belongs_to = array('user');

Pengguna dapat memposting beberapa blog, jadi kita tambahkan baris ini:

protected static $_has_many = array('posts');

Cara cepat untuk menguji ini bekerja adalah dengan menembakkan konsol oil:

Fuel 1.1-rc2 - PHP 5.3.6 (cli) (Sep  8 2011 19:31:33) [Darwin]
>>> $post = Model_Post::find('first');
>>> $post->user->username
admin
-- Ctrl + C to exit

Bagus, hubungannya bekerja!

Sekarang dalam pandangan kami dapat bekerja dengan $post->user dan tampilkan nama mereka, jadi mari kita mengubah fuel/app/views/blog/view.php:

<h2><?php echo $post->title ?></h2>

<p>
	<strong>Posted: </strong><?php echo date('nS F, Y', $post->created_at) ?> (<?php echo Date::time_ago($post->created_at)?>)
	by <?php echo $post->user->username ?>
</p>

<p><?php echo nl2br($post->body) ?></p>

Melakukan hal-hal dengan cara ini disebut lazy loading. Apa yang pada dasarnya terjadi adalah bahwa ketika Anda meminta $post->user ORM mengembalikan objek pengguna berdasarkan isi user_id. Ini berarti untuk mendapatkan pos dan pengguna pertama dua query, mendapatkan kedua akan ketiga, dll dan begitu itu dapat berakhir menjadi sangat lambat dengan semua query tambahan ini.

Untuk meningkatkan kinerja Anda dapat beralih dari lazy loading eager loading yang pada dasarnya menceritakan ORM yang Anda akan bergabung dengan pengguna pada sehingga harus melakukannya sebagai bagian dari query pertama. Ini dapat membuat permintaan lebih besar satu tetapi ORM akan mengiris itu baik untuk Anda dan Anda tidak akan melihat perbedaan.

$post = Model_Post::find_by_slug($slug, array('related' => array('user')));

Jika Anda melihat query ORM menghasilkan, itu akan menjadi sesuatu seperti ini:

SELECT <code>t0</code>.<code>id</code> AS <code>t0_c0</code>, <code>t0</code>.<code>title</code> AS <code>t0_c1</code>, <code>t0</code>.<code>slug</code> AS <code>t0_c2</code>, <code>t0</code>.<code>summary</code> AS <code>t0_c3</code>, <code>t0</code>.<code>body</code> AS <code>t0_c4</code>, <code>t0</code>.<code>user_id</code> AS <code>t0_c5</code>, <code>t0</code>.<code>created_at</code> AS <code>t0_c6</code>, <code>t0</code>.<code>updated_at</code> AS <code>t0_c7</code>, <code>t1</code>.<code>id</code> AS <code>t1_c0</code>, <code>t1</code>.<code>username</code> AS <code>t1_c1</code>, <code>t1</code>.<code>password</code> AS <code>t1_c2</code>, <code>t1</code>.<code>group</code> AS <code>t1_c3</code>, <code>t1</code>.<code>email</code> AS <code>t1_c4</code>, <code>t1</code>.<code>last_login</code> AS <code>t1_c5</code>, <code>t1</code>.<code>login_hash</code> AS <code>t1_c6</code>, <code>t1</code>.<code>profile_fields</code> AS <code>t1_c7</code>, <code>t1</code>.<code>created_at</code> AS <code>t1_c8</code>, <code>t1</code>.<code>updated_at</code> AS <code>t1_c9</code> FROM (SELECT <code>t0</code>.<code>id</code>, <code>t0</code>.<code>title</code>, <code>t0</code>.<code>slug</code>, <code>t0</code>.<code>summary</code>, <code>t0</code>.<code>body</code>, <code>t0</code>.<code>user_id</code>, <code>t0</code>.<code>created_at</code>, <code>t0</code>.<code>updated_at</code> FROM <code>posts</code> AS <code>t0</code> ORDER BY <code>t0</code>.<code>id</code> ASC LIMIT 1) AS <code>t0</code> LEFT JOIN <code>users</code> AS <code>t1</code> ON (<code>t0</code>.<code>user_id</code> = <code>t1</code>.<code>id</code>) WHERE (<code>t0</code>.<code>slug</code> = 'women-love-guys-who-use-fuelphp') ORDER BY <code>t0</code>.<code>id</code> ASC

Pada awalnya ini mungkin terlihat gila, tapi ORM tahu persis apa yang terjadi. Menggunakan pendekatan ini di masa lalu saya telah mengurangi sebuah aplikasi dari menjalankan 300 + query pada halaman sibuk (sangat lambat) ke sekitar 2 (sangat cepat).

Langkah 8 - menambahkan komentar

Banyak tutorial "membuat sebuah blog" berhenti sebelum mereka mendapatkan komentar yang saya pikir adalah pemandangan bawah utama. Kebutuhan setiap blog komentar dan kami ingin menambahkannya dengan cepat sehingga kita dapat pergi dan melakukan sesuatu yang lebih menyenangkan, sehingga kita dapat menggunakan kode generasi untuk membangun antarmuka admin:

$ oil generate admin comments name:string email:string website:string message:text post_id:int
	Creating migration: /Users/phil/Sites/blog/fuel/app/migrations/003_create_comments.php
	Creating model: /Users/phil/Sites/blog/fuel/app/classes/model/comment.php
	Creating controller: /Users/phil/Sites/blog/fuel/app/classes/controller/admin/comments.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/comments/index.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/comments/view.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/comments/create.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/comments/edit.php
	Creating view: /Users/phil/Sites/blog/fuel/app/views/admin/comments/_form.php

$ oil refine migrate
Migrated app:default to latest version: 3.

Komentar akan membutuhkan beberapa tweak yang serupa seperti Post sehingga membuat mereka kemudian setup hubungan.

Model_User

protected static $_has_many = array('posts', 'comments');
protected static $_belongs_to = array('user');

Model_Post

protected static $_belongs_to = array('user');
protected static $_has_many = array('comments');

Model_Comment

protected static $_belongs_to = array('post', 'user');

Menambahkan komentar melalui antarmuka cara curang, dengan pergi ke http://localhost/blog/public/admin/comments/create dan memasuki salah satu

Sekarang kita dapat menguji hubungan di konsol lagi:

Fuel 1.1-rc2 - PHP 5.3.6 (cli) (Sep  8 2011 19:31:33) [Darwin]
>>> Model_Post::find(1)->comments
array (
  1 => 
  Model_Comment::__set_state(array(
   '_is_new' => false,
   '_frozen' => false,
   '_data' => 
  array (
  'id' => '1',
  'name' => 'Phil Sturgeon',
  'email' => '[email protected]',
  'website' => 'http://philsturgeon.co.uk/',
  'message' => 'This is an epic article.',
  'post_id' => '1',
  'created_at' => '1322931744',
  'updated_at' => '1322931744',
  ),
   '_original' => 
  array (
  'id' => '1',
  'name' => 'Phil Sturgeon',
  'email' => '[email protected]',
  'website' => 'http://philsturgeon.co.uk/',
  'message' => 'This is an epic article.',
  'post_id' => '1',
  'created_at' => '1322931744',
  'updated_at' => '1322931744',
  ),
   '_data_relations' => 
  array (
  ),
   '_original_relations' => 
  array (
  ),
   '_view' => NULL,
   '_iterable' => 
  array (
  ),
  )),
)

Output array benda ORM sedikit verbose, tetapi setidaknya kita bisa melihat data. Ini berarti hubungan bekerja dengan baik, jadi mari kita mengubah ORM query dalam blog controller action_view() metode untuk menyertakan komentar:

$post = Model_Post::find_by_slug($slug, array('related' => array('user', 'comments')));

Sekarang memperbarui tampilan blog untuk output komentar dan memiliki form untuk menambahkan lebih banyak:

<h2><?php echo $post->title ?></h2>

<p>
	<strong>Posted: </strong><?php echo date('nS F, Y', $post->created_at) ?> (<?php echo Date::time_ago($post->created_at)?>)
	by <?php echo $post->user->username ?>
</p>

<p><?php echo nl2br($post->body) ?></p>

<hr />

<h3 id="comments">Comments</h3>

<?php foreach ($post->comments as $comment): ?>

	<p><?php echo Html::anchor($comment->website, $comment->name) ?> said "<?php echo $comment->message?>"</p>

<?php endforeach; ?>

<h3>Write a comment</h3>

<?php echo Form::open('blog/comment/'.$post->slug) ?>

<div class="row">
	<label for="name">Name:</label>
	<div class="input"><?php echo Form::input('name'); ?></div>
</div>

<div class="row">
	<label for="website">Website:</label>
	<div class="input"><?php echo Form::input('website'); ?></div>
</div>

<div class="row">
	<label for="email">Email:</label>
	<div class="input"><?php echo Form::input('email'); ?></div>
</div>

<div class="row">
	<label for="message">Comment:</label>
	<div class="input"><?php echo Form::textarea('message'); ?></div>
</div>

<div class="row">
	<div class="input"><?php echo Form::submit('submit'); ?></div>
</div>

<?php echo Form::close() ?>

Kode ini akan menampilkan semua komentar dalam style yang sangat dasar diikuti oleh form benar-benar sederhana menggunakan Twitter Bootstrap markup. Saya yakin Anda dapat menyiapkan beberapa styling untuk bagian komentar.

Kita dapat melihat komentar sedang ditampilkan dan apapun yang ditambahkan juga akan diletakkan. Jadi tahap berikutnya dan terakhir dalam proses adalah untuk mendapatkan komentar yang disimpan.

Sebaris dengan Form::open('blog/comment/'.$post->slug) akan menetapkan action untuk blog/comment/women-love-guys-who-use-fuelphp yang berarti Controller_Blog butuh action_comment($slug) metode baru yang seharusnya terlihat seperti ini:

public function action_comment($slug)
{
	$post = Model_Post::find_by_slug($slug);
	
	// Lazy validation
	if (Input::post('name') AND Input::post('email') AND Input::post('message'))
	{
		// Create a new comment
		$post->comments[] = new Model_Comment(array(
			'name' => Input::post('name'),
			'website' => Input::post('website'),
			'email' => Input::post('email'),
			'message' => Input::post('message'),
			'user_id' => $this->current_user->id,
		));
		
		// Save the post and the comment will save too
		if ($post->save())
		{
			$comment = end($post->comments);
			Session::set_flash('success', 'Added comment #'.$comment->id.'.');
		}
		else
		{
			Session::set_flash('error', 'Could not save comment.');
		}
		
		Response::redirect('blog/view/'.$slug);
	}
	
	// Did not have all the fields
	else
	{
		// Just show the view again until they get it right
		$this->action_view($slug);
	}
}

Ringkasan

Artikel ini melewatkan beberapa hal seperti cara set up sebuah URL cantik bukan localhost/blog/public dan bagaimana menggunakan validasi form dalam model atau controller, tetapi semua ini dapat ditemukan dalam dokumentasi FuelPHP. Aku merencanakan untuk menyentuh pada hal-hal seperti Upload File dan migrasi sedikit lebih tapi kembali ini semua sudah didokumentasikan.

Anda harus memiliki kode cukup sekarang untuk memilih terpisah dan bermain dengan, dan proyek apa pun yang Anda memilih untuk bekerja dengan FuelPHP sudah memiliki sebuah blog sekarang - jadi melempar halaman splash, desain dan Anda siap untuk membuat SquareFaceTwitBook berikutnya.