Docstoc

Tugas Pemrograman Web Lanjut

Document Sample
Tugas Pemrograman Web Lanjut Powered By Docstoc
					Membangun Admin Panel dengan Kerangka Bahan Bakar PHP
Philip Sturgeon pada 12 Desember 2011 dengan 106 komentar
Tutorial Detail
  Program: Bahan Bakar PHP Framework
  Versi: 1.1.0
  Kesulitan: Mudah
  Perkiraan Waktu Penyelesaian: 2 jam

Pada bagian pertama dari seri ini, kami mengambil melihat dasar-dasar kerangka FuelPHP.
Dalam paruh kedua, kami akan melangkah ke atas gigi dan pindah ke beberapa topik yang
lebih maju! Kami akan membuat sebuah panel admin untuk aplikasi kita, membahas
penggunaan umum dari ORM dan menggunakan paket Authentication untuk membatasi
akses.


Pengenalan

Karena Bahan Bakar artikel pertama telah diubah namanya menjadi FuelPHP. Juga tidak
seperti artikel pertama yang didasarkan pada v1.0.1 artikel ini membutuhkan v1.1.0 sehingga
beberapa hal kecil yang berbeda. Semua teori yang telah Anda pelajari dari artikel pertama
masih akurat dan tidak banyak yang berubah jadi ini harus mudah.
Langkah 1 - Mengatur Minyak

Jika Anda belum menginstal minyak utilitas baris perintah dan cukup beruntung untuk dapat
berjalan pada Linux, Mac, Solaris, dll kemudian melakukannya dengan perintah berikut:

$ Curl get.fuelphp.com / minyak | sh

Langkah 2 - Membuat Aplikasi Baru

Perintah minyak akan membantu Anda membuat proyek baru dengan beberapa kunci stroke
dan alias minyak php saat berada di dalam aplikasi FuelPHP Anda:

$ Minyak membuat Situs / blog
$ Cd Situs / blog

Ini akan membuat sebuah aplikasi blog bagi kita dan dengan asumsi Anda memiliki Apache
atau beberapa web server lain yang berjalan pada folder "Situs" Anda harus dapat memuat
URL berikut dan melihat halaman selamat datang.
alt teks

Sekarang FuelPHP yang hidup dan server web Anda jelas bekerja, kita bisa mulai
mengkonfigurasi aplikasi kita.
Langkah 3 - Konfigurasi Aplikasi Anda

Buka editor favorit anda dan kami akan mulai dengan membuat koneksi database dan
mengkonfigurasi aplikasi. Ini hampir identik dengan v1.0.x, sehingga membuat database dan
mengatur pengguna SQL Anda namun yang biasa Anda lakukan. Ketika datang ke
konfigurasi database ada dua perbedaan:

  PDO sekarang driver default
  FuelPHP v1.1 memiliki lingkungan berbasis folder config sekarang.

Perubahan ini cukup sederhana, tetapi Anda dapat bertukar kembali untuk menggunakan
driver MySQL asli jika Anda suka. PDO lebih bermanfaat untuk pengembang seperti itu
berarti bahwa aplikasi Anda akan bekerja dengan hampir semua database engine tidak hanya
sedikit yang telah FuelPHP driver khusus dibangun untuk mereka. Itu berarti ini bisa dengan
mudah menjadi SQLite atau PostgreSQL.

Hanya membuka bahan bakar / app / config / pengembangan / db.php dan memodifikasi
konfigurasi Anda, di mana dbname = blog adalah apa pun database Anda disebut dan
username dan password Anda sendiri untuk server database:

kembali array (
  'Default' => array (
 'Koneksi' => array (
 'Dsn' => 'mysql: host = localhost; dbname = blog,
 'Username' => 'root',
 'Password' => 'password',
 ),
  ),
);

Selanjutnya Anda hanya akan perlu untuk membuka bahan bakar / app / config / config.php
dan mengaktifkan paket auth dan orm seperti yang disarankan di posting pertama.

/ *************************************************
************************* /
/ * Selalu Muat * /
/ *************************************************
************************* /
'Always_load' => array (

'Paket' => array (
'Auth',
'Orm',
),

Dalam file konfigurasi, kita perlu membuat satu perubahan kecil untuk array
whitelisted_classes yang akan memungkinkan kita untuk melewatkan objek validasi untuk
melihat:

'Whitelisted_classes' => array (
'Bahan Bakar \ \ Inti \ \ Respon',
'Bahan Bakar \ \ Inti \ \ View',
'Bahan Bakar \ \ Inti \ \ ViewModel',
'Bahan Bakar \ Inti \ Validasi',
'Penutupan',
),

Menyiapkan Grup

Paket auth disertakan dengan FuelPHP adalah sopir berdasarkan dan secara default kita
menggunakan "SimpleAuth" yang merupakan sopir hanya disertakan dalam paket. Ketika
Anda lebih berpengalaman dengan FuelPHP, Anda dapat mulai membuat driver khusus untuk
mengintegrasikan dengan sistem user lain - seperti pihak ketiga forum, sistem manajemen
konten, dll

Untuk mengaktifkan kelompok untuk SimpleAuth, kita cukup membuka bahan bakar / paket /
auth / config / simpleauth.php dan mengatur kelompok sebagai berikut:

kembali array (
  'Kelompok' => array (
 -1 => Array ('name' => 'Banned', 'peran' => array ('dilarang')),
 0 => array ('name' => 'Tamu', 'peran' => array ()),
 1 => array ('name' => 'Pengguna', 'peran' => array ('user')),
 50 => array ('name' => 'Moderator', 'peran' => array ('user', 'moderator')),
 100 => array ('name' => 'Administrator', 'peran' => array ('user', 'moderator', 'admin')),
  ),
);

Ini dapat, tentu saja, apa saja, tetapi cukup standar untuk aplikasi yang paling dan akan
bekerja untuk tutorial ini.
Langkah 4 - Membuat Pengguna

Seperti kita sedang membangun sebuah panel admin, kita perlu membuat tabel pengguna dan
kemudian mengisinya dengan catatan pengguna yang akan menjadi administrator pertama.
Kita bisa menggunakan sesuatu seperti phpMyAdmin atau GUI seperti Navicat, tetapi lebih
baik untuk melakukan sesuatu melalui Minyak jadi kita tinggal di dalam basis kode kita. Ini
berarti sandi hashing yang asin dengan benar dengan apa driver yang akan digunakan - dan
bagaimana kita akan melakukannya:

$ Minyak menghasilkan model yang username pengguna: varchar [50] kata sandi: string
kelompok: Email int: last_login string: login_hash int: profile_fields string: teks
 Membuat model: / Users / phil / Tempat / blog / bahan bakar / app / kelas / model / user.php
 Membuat migrasi: / Users/phil/Sites/blog/fuel/app/migrations/001_create_users.php
$ Minyak menyempurnakan bermigrasi

Hal ini menciptakan model pengguna untuk kami dan menciptakan migrasi lain yang akan
membangun tabel user kita ketika minyak menyempurnakan tugas bermigrasi dijalankan.
Selanjutnya kita harus membuat user Administrator, yang, sekali lagi, kita bisa melakukan
melalui GUI tapi di mana menyenangkan di itu?

$ Konsol minyak
Bahan Bakar 1,1-RC1 - PHP 5.3.6 (cli) (8 September 2011 19:31:33) [Darwin]
>>> Tupoksi :: create_user ('admin', 'password', 'phil@example.com', 100);
1
- Ctrl + C untuk keluar
Kami telah menggunakan Console Minyak untuk menulis kode secara real-time dan
mendapatkan tanggapan. Tupoksi :: create_user () disahkan username, password, alamat
email dan group_id untuk admin, yang untuk sekarang kita hanya akan menggunakan 100 -
yang kita tentukan dalam konfigurasi. Yang 1 adalah respon dari kode, yang berarti user_id
memiliki nilai 1.
Langkah 5 - Kode Generasi

  Generator adalah cara yang bagus untuk membangun sekelompok kode dari awal dan
mendapatkan mulai berjalan.

Sebagaimana dijelaskan dalam artikel pertama kita dapat menggunakan perancah untuk
membangun potongan besar aplikasi dengan cepat. Hal ini dilakukan melalui perintah minyak
dan semua sangat opsional, tetapi merupakan cara yang bagus untuk membangun sekelompok
kode dari awal. Beberapa orang melihat pembuatan kode sebagai "alat untuk orang yang
tidak tahu bagaimana kode" atau berpikir semacam ilmu hitam, tetapi jika Anda baru untuk
kerangka dan tidak mau harus belajar bagaimana untuk menempatkan semuanya bersama-
sama kemudian mendapatkan sistem yang membuat kode untuk Anda adalah bukan hal yang
buruk.

FuelPHP v1.1 mengambil generasi kode satu langkah kecil lebih lanjut. Bukan hanya
menciptakan perancah (CRUD tidak dilindungi) kini Anda dapat menghasilkan kode Admin.
Ini bekerja dengan cara yang persis sama tetapi mengimplementasikan template admin
sederhana, controller admin, dll dan menggunakan paket auth untuk mengunci kode yang
dihasilkan Anda. Mengambil keuntungan dari Bootstrap Twitter, ini semua terlihat cukup
baik untuk digunakan dan dengan hanya sedikit tweaking Anda akan memiliki sebuah
aplikasi yang Anda bisa mengirimkannya.

Hal ini dilakukan melalui baris perintah dengan menggunakan perintah minyak. Kami akan
menghasilkan beberapa kode kemudian berjalan melewatinya.

$ Minyak menghasilkan judul admin posting: siput string: String ringkasan: tubuh teks:
user_id teks: int
Membuat controller: / Users / phil / Tempat / blog / bahan bakar / app / kelas / controller /
base.php
Membuat controller: / Users / phil / Tempat / blog / bahan bakar / app / kelas / controller /
admin.php
Membuat views: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
template.php
Membuat views: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
dashboard.php
Membuat views: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / login.php
Membuat migrasi: / Users/phil/Sites/blog/fuel/app/migrations/002_create_posts.php
Membuat model: / Users / phil / Tempat / blog / bahan bakar / app / kelas / model / post.php
Membuat controller: / Users / phil / Tempat / blog / bahan bakar / app / kelas / controller /
admin / posts.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / posts /
index.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / post /
view.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / posts /
create.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / posts /
edit.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin / posts /
_form.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / template.php

Hal ini cukup sedikit kode karena pertama kalinya telah dijalankan. FuelPHP akan membuat
template dasar dan file, kemudian membangun komponen MVC untuk bagian posting. Ingat,
ini adalah seperti menulis kode sendiri, tapi lebih cepat. Anda dapat melihat output ini dengan
pergi ke / blog / public / admin / posting:
Tulisan - kode Generated Admin
Memahami Controller

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

abstrak kelas Controller_Base meluas Controller_Template {

fungsi publik sebelum ()
{
orang tua sebelum :: ();

/ / Menetapkan current_user untuk contoh sehingga kontroler dapat menggunakannya
$ This-> current_user = Tupoksi :: cek ()? Model_User :: find (Arr :: get (Tupoksi ::
get_user_id (), 1)): null;

/ / Set variabel global sehingga pandangan dapat menggunakannya
View :: set_global ('current_user', $ this-> current_user);
}

}

Dengan memperluas Controller_Template, semua pandangan akan dibungkus dengan
template secara otomatis. Kemudian pada fungsi sebelum () kita melakukan sedikit logika
untuk mendapatkan pengguna saat ini dan membuatnya tersedia sebagai $ this-> current_user
di controller dan $ current_user dalam pandangan.

Controller lain akan dibangun Controller_Admin disebut yang meluas Controller_Base,
sehingga serta memiliki pengguna saat ini sedang dibangun kita dapat memeriksa untuk
melihat apakah pengguna sebenarnya admin:

abstrak kelas Controller_Admin meluas Controller_Base {

public $ template = 'admin / template';

fungsi publik sebelum ()
{
orang tua sebelum :: ();
if (Tupoksi :: anggota (100) dan Permintaan :: aktif () -> action = 'login')
{
Tanggapan :: redirect ('admin / login');
}
}

/ / ....

}

Anda akan melihat bahwa kontroler ini menetapkan template kustom jadi bukan mencari
bahan bakar / app / views / template.php, itu akan mencari bahan bakar / app / views / admin /
template.php. Kemudian jika pengguna tidak cocok anggota (100) - ID grup admin ditetapkan
sebelumnya - mereka akan dikirim dari halaman login.
Memperluas Controller

Satu fitur yang sangat berguna yang memiliki FuelPHP adalah untuk memungkinkan Anda
untuk memperpanjang pengendali lainnya. Biasanya mereka hanya dimuat langsung oleh
kelas Permintaan setelah diarahkan oleh URL, tapi kadang-kadang berguna untuk
memperpanjang pengendali untuk berbagi logika atau metode. Dalam hal ini, kita sudah
memeriksa hak akses di Controller_Admin sehingga kita dapat memperpanjang controller
yang menggunakan kembali logika ini.

Controller_Admin_Posts meluas Controller_Admin. Ini berarti mengandung sama sebelum ()
memeriksa dan karena itu dilindungi dengan cara yang sama seperti controller lain di panel
admin Anda.
Sekarang Apa?

Pembuatan kode pada dasarnya hanya langkah pertama dalam bekerja pada aplikasi. Kami
masih perlu tweak bentuk kami dan menciptakan sebuah frontend. Misalnya, jika Anda pergi
untuk membuat atau mengedit posting maka akan terlihat bidang user_id sebagai kotak teks.
Langkah 6 - Memperbarui Bentuk CRUD

Kita akan ingin memodifikasi metode action_create () kita dalam bahan bakar / app / kelas /
admin / posts.php jadi kami memiliki daftar pengguna yang tersedia. Untuk melakukan ini
kita dapat mengganti metode dengan kode ini:

fungsi publik action_create ($ id = null)
{
$ View = View :: bengkel ('admin / post / buat');

jika (Input :: method () == 'POST')
{
$ Post = Model_Post :: menempa (array (
'Title' => Input :: post ('title'),
'Siput' => Inflector :: friendly_title (Input :: post ('title'), '-', benar),
'Ringkasan' => Input :: pos ('ringkasan'),
'Tubuh' => Input :: pos ('tubuh'),
'User_id' => Input :: pos ('user_id'),
));

if ($ post dan $ post-> save ())
{
Sesi :: set_flash ('sukses', 'Added post #' $ post-> id. '.'.);
Tanggapan :: redirect ('admin / posting');
}

lain
{
Sesi :: set_flash ('kesalahan', 'Tidak dapat menyimpan posting.');
}
}

/ / Set beberapa data
$ View-> set_global ('pengguna', Arr :: assoc_to_keyval (Model_User :: find ('all'), 'id',
'username'));

$ This-> template-> title = "Buat Post";
$ This-> template-> content = $ view;
}

Ini adalah sama dengan kode sebelumnya dengan dua perubahan:

$ View = View :: bengkel ('admin / post / buat');

Ini menciptakan objek View baru. Kami dapat menetapkan properti pandangan ini dengan
menetapkan mereka sebagai properti, sehingga pengguna data kami dapat lulus dengan
mudah dan biasanya bekerja sedikit seperti ini:

$ View-> pengguna = array (1 => "User 1", 2 => "User 2");

Sekarang kita membuat update mirip dengan action_edit ():

fungsi publik action_edit ($ id = null)
{
$ View = View :: bengkel ('admin / post / edit');

$ Post = Model_Post :: find ($ id);

jika (Input :: method () == 'POST')
{
$ Post-> title = Masukan :: post ('title');
$ Post-> siput = Inflector :: friendly_title (Input :: post ('title'), '-', true);
$ Post-> = ringkasan Masukan :: pos ('ringkasan');
$ Post-> tubuh = :: Masukan pos ('tubuh');
$ Post-> user_id = :: Masukan pos ('user_id');

if ($ post-> save ())
{
Sesi :: set_flash ('sukses', 'Diperbarui post #' $ id.);
Tanggapan :: redirect ('admin / posting');
}

lain
{
Sesi :: set_flash ('kesalahan', 'Tidak dapat memperbarui posting #' $ id.);
}
}

lain
{
$ This-> template-> set_global ('post', $ post, false);
}

/ / Set beberapa data
$ View-> set_global ('pengguna', Arr :: assoc_to_keyval (Model_User :: find ('all'), 'id',
'username'));

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

Namun, karena pandangan create.php dan edit.php berbagi _form.php tema parsial, hanya
variabel dan properti diatur untuk yang satu tampilan tertentu kita perlu menggunakan View
:: set_global () metode:

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

Ini menggunakan objek Model_User untuk mendapatkan semua pengguna kami, maka rata
mereka untuk array asosiatif untuk formulir kami.

HTML sekarang harus berubah, sehingga menghapus div membungkus "siput" - kita akan
melakukannya diri kita sendiri dan ubah field user_id dari menjadi kotak input ke kotak pilih:

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

<div class="input">
User_id <php echo Formulir :: pilih ('user_id', Input :: pos ('user_id', isset ($ post) $ post-??>:
$ Current_user-> id), $ pengguna, array ('class' = > 'span6'));?>

</ Div>
</ Div>

Pengguna dropdown bentuk

Ini akan mengatur kotak untuk menampilkan semua pengguna dan default dengan arus login
pengguna jika tidak disediakan. Itulah hanya men-tweak kita perlu membuat pada titik ini,
jadi mari kita membuat sebuah frontend!
Frontend ini

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

Buat controller baru bahan bakar / app / kelas / controller / blog.php:

kelas Controller_Blog meluas Controller_Base
{
fungsi publik action_index ()
{
$ View = View :: bengkel ('blog / index');

$ View-> posts = Model_Post :: find ('all');

$ This-> template-> title = 'Blog saya tentang Stuff';
$ This-> template-> content = $ view;
}
}

Dan file tampilan bahan bakar / app / views / blog / index.php:

Recent Posts <h2> </ h2>

<Php foreach ($ posting sebagai $ post):?>

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

<p> <php echo $? post-> Ringkasan?> </ p>

<Php endforeach;?>

Ini hanyalah sebuah loop sederhana melalui array $ posting yang berisi semua artikel Anda.
Komentar bentuk

Sebuah loop foreach, hyperlink dan ringkasan yang kami butuhkan pada file tampilan dan
kami akan membuat file lain maksud untuk benar-benar melihat posting. Kita akan
menyebutnya metode controller action_view () dan membuat file view yang disebut
view.php:

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

<strong> <p> Posted: </ strong> <php echo date ('NS M, Y', $ post-> created_at)> (<php
echo Tanggal :: time_ago ($ post-> created_at)? >) </ p>

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

Ini adalah metode untuk kontroler blog:
fungsi publik action_view ($ siput)
{
$ Post = Model_Post :: find_by_slug ($ siput);

$ This-> template-> title = $ post-> title;
$ This-> template-> isi = Lihat :: bengkel ('blog / view', array (
'Post' => $ pos,
));
}

Para find_by_slug () metode adalah "metode ajaib" yang akan membangun MANA siput =
"foo" dalam permintaan Anda dan kembali contoh Model_Post tunggal dengan data tersebut.
Komentar bentuk

Sekarang orang dapat melihat Anda - mengerikan unstyled - situs dan melihat sebuah blog
dasar, dan Anda memiliki antarmuka admin untuk mengelolanya!
Langkah 7 - Menggunakan ORM

Sejauh ini kita telah menggunakan ORM untuk model kita untuk melakukan CRUD dasar
tapi kita belum melihat ada hubungannya dengan hubungan. ORM membuat ini sangat
mudah, baik itu singkatan dari "Pemetaan Objek Relasional" karena suatu alasan. Untuk
mengatur hubungan semua yang perlu kita lakukan adalah memodifikasi model kami sedikit
untuk menjelaskan bagaimana ORM harus berhubungan data.

Sebuah pos yang dibuat oleh satu pengguna, jadi kita katakan itu "milik" pengguna. Dalam
Model_Post kita dapat menambahkan:

dilindungi statis $ _belongs_to = array ('user');

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

dilindungi statis $ _has_many = array ('posting');

Cara cepat untuk menguji ini bekerja adalah dengan menembak sampai konsol minyak:

Bahan Bakar 1.1-rc2 - PHP 5.3.6 (cli) (8 September 2011 19:31:33) [Darwin]
>>> $ Post = Model_Post :: find ('pertama');
>>> $ Post-> user-> username
admin
- Ctrl + C untuk keluar

Nice, hubungan bekerja!

Sekarang dalam pandangan kita dapat bekerja dengan $ post-> user dan output nama mereka,
jadi mari kita bakar perubahan / app / views / blog / view.php:

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

<p>
<strong> Posted: </ strong> <php echo date ('NS M, Y', $ post-> created_at)> (<php echo
Tanggal :: time_ago ($ post-> created_at)>??)?
oleh <php menggemakan? $ post-> user-> username>
</ P>

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

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

Untuk meningkatkan kinerja Anda dapat beralih dari loading malas untuk eager loading yang
pada dasarnya menceritakan ORM Anda akan bisa bergabung pengguna pada jadi harus
melakukannya sebagai bagian dari query pertama. Hal ini dapat membuat untuk satu
permintaan yang lebih besar tetapi ORM akan mengiris itu baik untuk Anda dan Anda wont
melihat perbedaan.

$ Post = Model_Post :: find_by_slug ($ siput, array ('terkait' => array ('user')));

Jika Anda melihat permintaan ORM menghasilkan, maka akan seperti ini:

SELECT <code> t0 </ code> <code> id. </ Code> SEBAGAI <code> t0_c0 </ code>,
<code> t0 </ code>. <code> Judul </ code> SEBAGAI <code> t0_c1 </ code>, <code> t0 </
code> <code> siput </ code>. SEBAGAI <code> t0_c2 </ code>, <code> t0 </ code>
<code> ringkasan </ code>. AS <code> t0_c3 </ code>, <code> t0 </ code> <code> tubuh </
code>. SEBAGAI <code> t0_c4 </ code>, <code> t0 </ code>. <code> user_id < / code>
SEBAGAI <code> t0_c5 </ code>, <code> t0 </ code> <code> created_at. </ code>
SEBAGAI <code> t0_c6 </ code>, <code> t0 </ code>. < code> updated_at </ code>
SEBAGAI <code> t0_c7 </ code>, <code> t1 </ code> <code> id. </ code> SEBAGAI
<code> t1_c0 </ code>, <code> t1 </ code> <code> nama pengguna </ code.> SEBAGAI
<code> t1_c1 </ code>, <code> t1 </ code>. <code> password </ code> SEBAGAI <code>
t1_c2 </ code>, <kode > t1 </ code> <code> kelompok </ code.> SEBAGAI <code> t1_c3
</ code>, <code> t1 </ code>. <code> email </ code> SEBAGAI <code> t1_c4 </ code >,
<code> t1 </ code> <code> last_login. </ code> SEBAGAI <code> t1_c5 </ code>, <code>
t1 </ code> <code> login_hash. </ code> SEBAGAI <code> t1_c6 </ code>, <code> t1 </
code> <code> profile_fields. </ code> SEBAGAI <code> t1_c7 </ code>, <code> t1 </
code> <code> created_at. </ code> SEBAGAI <code> t1_c8 </ code>, <code> t1 </ code>
<code> updated_at. </ code> SEBAGAI <code> t1_c9 </ code> DARI (SELECT <code> t0
</ code>. <kode > id </ code>, <code> t0 </ code> <code> judul </ code.>, <code> t0 </
code>. <code> siput </ code>, <code> t0 </ code > <code> ringkasan </ code.>, <code> t0
</ code>. <code> tubuh </ code>, <code> t0 </ code>. <code> user_id </ code>, <code> t0
</ code> <code> created_at. </ code>, <code> t0 </ code>. <code> updated_at </ code>
DARI <code> posting </ code> SEBAGAI <code> t0 </ code> ORDER BY <code> t0 </
code> <code> id. </ code> ASC LIMIT 1) SEBAGAI <code> t0 </ code> LEFT JOIN
<code> pengguna </ code> SEBAGAI <code> t1 </ code > ON (<code> t0 </ code> <code>
user_id. </ code> = <code> t1 </ code>. <code> id </ code>) WHERE (<code> t0 </ code>.
<code> siput </ code> = 'wanita-cinta-orang-yang-digunakan-fuelphp') ORDER BY <code>
t0 </ code> <code> id. </ code> ASC
Pada awalnya ini mungkin terlihat gila, tapi ORM tahu persis apa yang sedang terjadi.
Dengan menggunakan pendekatan ini di masa lalu saya telah mengurangi aplikasi dari
menjalankan query + 300 pada halaman sibuk (sangat lambat) turun menjadi sekitar 2 (sangat
cepat).
Langkah 8 - Menambahkan Komentar

Banyak "membuat blog" tutorial berhenti sebelum mereka sampai ke komentar yang menurut
saya adalah di bawah melihat-besar. Setiap blog perlu komentar dan kita ingin menambahkan
mereka dengan cepat sehingga kami dapat pergi dan melakukan sesuatu yang menyenangkan
lebih banyak, sehingga kita dapat menggunakan generasi kode untuk membangun antarmuka
admin:

$ Minyak menghasilkan nama admin komentar: Email string: situs string: pesan string:
post_id teks: int
Membuat migrasi: / Users/phil/Sites/blog/fuel/app/migrations/003_create_comments.php
Membuat model: / Users / phil / Tempat / blog / bahan bakar / app / kelas / model /
comment.php
Membuat controller: / Users / phil / Tempat / blog / bahan bakar / app / kelas / controller /
admin / comments.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
komentar / index.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
komentar / view.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
komentar / create.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
komentar / edit.php
Membuat tampilan: / Users / phil / Tempat / blog / bahan bakar / app / views / admin /
komentar / _form.php

$ Minyak menyempurnakan bermigrasi
Aplikasi bermigrasi: default ke versi terbaru: 3.

Komentar akan membutuhkan beberapa tweak yang sama seperti Posting itu sehingga
membuat mereka kemudian kami mendirikan hubungan.

Model_User

dilindungi statis $ _has_many = array ('posting', 'komentar');
dilindungi statis $ _belongs_to = array ('user');

Model_Post

dilindungi statis $ _belongs_to = array ('user');
dilindungi statis $ _has_many = array ('komentar');

Model_Comment

dilindungi statis $ _belongs_to = array ('post', 'user');
Tambah komentar melalui antarmuka cara curang, dengan pergi ke
http://localhost/blog/public/admin/comments/create dan memasukkan satu
Komentar admin

Sekarang kita dapat menguji hubungan di konsol lagi:

Bahan Bakar 1.1-rc2 - PHP 5.3.6 (cli) (8 September 2011 19:31:33) [Darwin]
>>> Model_Post :: find (1) -> komentar
array (
  1 =>
  Model_Comment :: __set_state (array (
   '_is_new' => False,
   '_frozen' => False,
   '_data' =>
  array (
  'Id' => '1 ',
  'Name' => 'Phil Sturgeon',
  'Email' => 'email@philsturgeon.co.uk',
  'Situs' => 'http://philsturgeon.co.uk/',
  'Pesan' => 'Ini adalah artikel epik.',
  'Post_id' => '1 ',
  'Created_at' => '1322931744 ',
  'Updated_at' => '1322931744 ',
  ),
   '_original' =>
  array (
  'Id' => '1 ',
  'Name' => 'Phil Sturgeon',
  'Email' => 'email@philsturgeon.co.uk',
  'Situs' => 'http://philsturgeon.co.uk/',
  'Pesan' => 'Ini adalah artikel epik.',
  'Post_id' => '1 ',
  'Created_at' => '1322931744 ',
  'Updated_at' => '1322931744 ',
  ),
   '_data_relations' =>
  array (
  ),
   '_original_relations' =>
  array (
  ),
   '_view' => NULL,
   '_iterable' =>
  array (
  ),
  )),
)

Output dari sebuah array dari objek ORM adalah verbose sedikit, tapi setidaknya kita bisa
melihat data. Ini berarti hubungan tersebut bekerja dengan baik, jadi mari kita memodifikasi
query ORM di blog pengendali action_view () metode untuk memasukkan komentar:

$ Post = Model_Post :: find_by_slug ($ siput, array ('terkait' => array ('user', 'komentar')));

Sekarang memperbarui tampilan blog untuk menampilkan komentar dan memiliki bentuk
untuk menambahkan lebih lanjut:

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

<p>
<strong> Posted: </ strong> <php echo date ('NS M, Y', $ post-> created_at)> (<php echo
Tanggal :: time_ago ($ post-> created_at)>??)?
oleh <php menggemakan? $ post-> user-> username>
</ P>

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

<hr />

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

<Php foreach ($ post-> komentar sebagai $ komentar):?>

<p> <php echo? Html :: jangkar ($ comment-> situs, $ comment-> nama)?> kata "<php
echo? $ comment-> pesan>?" </ p>

<Php endforeach;?>

<h3> Beri Komentar </ h3>

<Php echo? Formulir :: open ('blog / komentar /' $ post-.> Siput)?>

<div class="row">
<label for="name"> Nama: </ label>
<div class="input"> <php echo Formulir :: input ('nama');?> </ div>
</ Div>

<div class="row">
<label for="website"> Situs web: </ label>
<div class="input"> <php echo Formulir :: input ('situs');?> </ div>
</ Div>

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

<div class="row">
<label for="message"> Komentar: </ label>
<div class="input"> <php echo Formulir :: textarea ('pesan');?> </ div>
</ Div>

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

<Php echo Formulir ::? Close ()?>

Kode ini akan menampilkan semua komentar dengan gaya yang sangat dasar diikuti dengan
bentuk yang sangat sederhana menggunakan markup Bootstrap Twitter. Saya yakin Anda
dapat menyiapkan beberapa styling untuk bagian komentar.
Komentar bentuk

Kita bisa melihat komentar tersebut menjadi output dan setiap yang ditambahkan juga akan
ditempatkan masuk Jadi tahap berikutnya dan terakhir dalam proses ini adalah untuk
mendapatkan komentar diselamatkan.

Garis dengan Formulir :: open ('blog / komentar /' $ post-> siput.) Akan mengatur tindakan
untuk blog / komentar / wanita-cinta-orang-yang-digunakan-fuelphp yang berarti
Controller_Blog membutuhkan action_comment metode baru ( $ siput) yang harus terlihat
seperti ini:

fungsi publik action_comment ($ siput)
{
$ Post = Model_Post :: find_by_slug ($ siput);

/ / Validasi Malas
jika (Input :: post ('nama') DAN Masukan :: pos ('email') DAN Masukan :: post ('pesan'))
{
/ / Buat komentar baru
$ Post-> komentar [] = Model_Comment baru (array (
'Name' => Input :: post ('name'),
'Situs' => Input :: post ('website'),
'Email' => Input :: pos ('email'),
'Pesan' => Input :: post ('pesan'),
'User_id' => $ this-> current_user-> id,
));

/ / Simpan posting dan komentar akan menghemat terlalu
if ($ post-> save ())
{
$ Komentar = end ($ post-> komentar);
Sesi :: set_flash ('sukses', 'Tambah komentar #' $ comment-> id.. '.');
}
lain
{
Sesi :: set_flash ('kesalahan', 'Tidak dapat menyimpan komentar.');
}

Tanggapan :: redirect ('blog / view /' $ siput.);
}

/ / Tidak punya semua bidang
lain
{
/ / Hanya menunjukkan pandangan lagi sampai mereka bisa melakukannya dengan benar
$ This-> action_view ($ siput);
}
}

Ringkasan

Artikel ini melewatkan beberapa hal seperti cara mengatur URL cantik bukan localhost / blog
/ publik dan bagaimana menggunakan validasi form dalam model atau controller, namun
semua ini dapat ditemukan dalam Dokumentasi FuelPHP. Saya berencana untuk menyentuh
pada hal-hal seperti Upload File dan Migrasi sedikit lebih tapi sekali lagi ini semua sudah
didokumentasikan.

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

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:30
posted:9/7/2012
language:Unknown
pages:16