ardent
1.0.0
Model pintar yang memvalidasi sendiri untuk Eloquent ORM Laravel Framework 5.
Berdasarkan bundel Aware untuk Laravel 3 oleh Colby Rabideau.
Hak Cipta (C) 2013-2015 Max Ehsan & Igor Santos
Kunjungi daftar Rilis kami. Changelog dibuat di sana :)
Tambahkan laravelbook/ardent sebagai persyaratan ke composer.json (lihat versi stabil terbaru kami di lencana!):
{"membutuhkan": {"laravelbook/ardent": "3.*"}} Perbarui paket Anda dengan composer update atau instal dengan composer install .
Anda juga dapat menambahkan paket menggunakan composer require laravelbook/ardent dan kemudian menentukan versi yang Anda inginkan (untuk saat ini, dev-master adalah pilihan terbaik Anda).
Jika Anda ingin menggunakan Ardent sebagai paket ORM mandiri, Anda diundang untuk melakukannya dengan menggunakan konfigurasi berikut di file boot/startup proyek Anda (tentu saja mengubah properti sesuai dengan database Anda):
LaravelArdentArdentArdent::configureAsExternal(array( 'driver' => 'mysql', 'host' => 'localhost', 'port' => 3306, 'database' => 'my_system', 'username' => 'myself', 'kata sandi' => 'h4ckr', 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci'), 'en'); //Bahasa Inggris adalah bahasa pesan default, boleh dikosongkan
Perkenalan
Memulai
Validasi Mudah dengan Ardent
Mengambil Kesalahan Validasi
Mengesampingkan Validasi
Pesan Kesalahan Validasi Kustom
Aturan Validasi Kustom
Kait model
Definisi hubungan yang lebih bersih
Secara Otomatis Menghidrasi Entitas Ardent
Secara Otomatis Membersihkan Data Formulir yang Berlebihan
Secara Otomatis Mengubah Atribut Teks Aman
Pembaruan dengan Aturan Unik
Seberapa sering Anda membuat ulang kode boilerplate yang sama di aplikasi yang Anda buat? Apakah kode pemrosesan formulir yang khas ini tampak terlalu familier bagi Anda?
Route::post('register', function() {$rules = array('name' => 'wajib|antara:3,80|alpha_dash','email' => 'wajib|antara:5,64|email |unique:pengguna','kata sandi' => 'wajib|min:6|konfirmasi','konfirmasi_kata sandi' => 'wajib|min:6');$validator = Validator::make(Input::all(), $rules);if ($validator->passes()) {
Pengguna::buat(array('nama' => Masukan::get('nama'),'email' => Masukan::dapatkan('email'),'kata sandi' => Hash::make(Input:: dapatkan('kata sandi'))
));return Redirect::to('/')->with('message', 'Terima kasih telah mendaftar!');
} else {return Redirect::to('/')->withErrors($validator->getMessages());
}
}
);Menerapkannya sendiri sering kali menghasilkan banyak kode boilerplate yang berulang. Sebagai bonus tambahan, Anda sebagai pengontrol (atau penangan rute) menjadi gemuk sebelum waktunya, dan kode Anda menjadi berantakan, jelek, dan sulit dipahami.
Bagaimana jika orang lain melakukan semua pekerjaan berat untuk Anda? Bagaimana jika, alih-alih memuntahkan kekacauan di atas, yang perlu Anda ketik hanyalah beberapa baris ini?...
Route::post('register', function() {$user = Pengguna baru;if ($user->save()) {return Redirect::to('/')->with('message', 'Terima kasih untuk mendaftar!');
} else {return Redirect::to('/')->withErrors($user->errors());
}
}
);Masuk Bersemangat!
Ardent - solusi satu atap yang bertenaga debu ajaib, ramah pergelangan tangan, untuk semua boilerplate sanitasi masukan Anda yang suram!
Selain itu, fungsi validasi input dapat dengan cepat menjadi membosankan untuk ditulis dan dipelihara. Ardent mengatasi kerumitan ini dengan menyediakan bantuan untuk mengotomatisasi banyak tugas yang berulang.
Namun, Ardent tidak hanya bagus untuk validasi input - ini juga akan membantu Anda mengurangi kode model data Eloquent Anda secara signifikan. Ardent sangat berguna jika Anda merasa lelah menulis kode yang sangat mirip berkali-kali di beberapa aplikasi individual.
Misalnya, pendaftaran pengguna atau pengiriman postingan blog adalah persyaratan pengkodean umum yang mungkin ingin Anda terapkan dalam satu aplikasi dan digunakan kembali di aplikasi lain. Dengan Ardent, Anda dapat menulis model cerdas dan sadar diri sekali saja, lalu menggunakannya kembali (tanpa atau sedikit modifikasi) di proyek lain. Setelah Anda terbiasa dengan cara melakukan sesuatu seperti ini, sejujurnya Anda akan bertanya-tanya bagaimana Anda bisa bertahan tanpa Ardent.
Tidak ada lagi cedera ketegangan otak yang berulang untuk Anda!
Ardent bertujuan untuk memperluas kelas dasar Eloquent tanpa mengubah fungsi intinya. Karena Ardent sendiri adalah turunan dari IlluminateDatabaseEloquentModel , semua model Ardent Anda sepenuhnya kompatibel dengan Eloquent dan dapat memanfaatkan kekuatan penuh OR/M Laravel yang mengagumkan.
Untuk membuat model Ardent baru, cukup buat kelas model Anda berasal dari kelas dasar Ardent . Pada contoh berikutnya kita akan menggunakan kelas dengan namespace lengkap untuk membuat contoh lebih rapi, namun Anda dianjurkan untuk use di semua kelas Anda:
gunakan LaravelArdentArdentArdent; Pengguna kelas memperluas Ardent {}Catatan: Anda dapat dengan bebas memadukan model Eloquent vanilla polos Anda dengan keturunan Ardent. Jika objek model tidak bergantung pada konten yang dikirimkan pengguna dan oleh karena itu tidak memerlukan validasi - Anda dapat membiarkan kelas model Eloquent apa adanya.
Model Ardent menggunakan kelas Validator bawaan Laravel. Mendefinisikan aturan validasi untuk suatu model sangatlah sederhana dan biasanya dilakukan di kelas model Anda sebagai variabel statis:
kelas Pengguna extends LaravelArdentArdentArdent { public static $rules = array('name' => 'wajib|antara:3,80|alpha_dash','email' => 'wajib|antara:5,64|email|unik:pengguna', 'password' => 'wajib|min:6|dikonfirmasi','password_confirmation' => 'wajib|min:6',
);
}Catatan : Anda juga bebas menggunakan sintaks array untuk aturan validasi. Saya harap Anda tidak keberatan dengan tautan dokumen Laravel yang lama, tetapi sebaik dokumentasi Laravel, referensi yang jelas tentang sintaksis pipa/array untuk aturan Validasi sayangnya hilang sejak 5.1.
Model Ardent memvalidasi dirinya sendiri secara otomatis ketika Ardent->save() dipanggil.
$pengguna = Pengguna baru;$pengguna->nama = 'John doe';$pengguna->email = '[email protected]';$pengguna->kata sandi = 'uji';$sukses = $pengguna->simpan( ); // mengembalikan nilai salah jika model tidak valid
Catatan: Anda juga dapat memvalidasi model kapan saja menggunakan metode
Ardent->validate().
Ketika model Ardent gagal divalidasi, objek IlluminateSupportMessageBag dilampirkan ke objek Ardent yang berisi pesan kegagalan validasi.
Ambil contoh pengumpulan pesan kesalahan validasi dengan metode Ardent->errors() atau properti Ardent->validationErrors .
Ambil semua kesalahan validasi dengan Ardent->errors()->all() . Ambil kesalahan untuk atribut tertentu menggunakan Ardent->validationErrors->get('attribute') .
Catatan: Ardent memanfaatkan objek MessagesBag Laravel yang memiliki metode kesalahan pemformatan yang sederhana dan elegan.
Ada dua cara untuk mengesampingkan validasi Ardent:
forceSave() memvalidasi model tetapi menyimpannya terlepas dari apakah ada kesalahan validasi atau tidak.
baik Ardent->save($rules, $customMessages) dan Ardent->validate($rules, $customMessages) mengambil dua parameter:
$rules adalah larik aturan Validator dengan bentuk yang sama seperti Ardent::$rules .
Hal yang sama juga berlaku untuk parameter $customMessages (sama seperti Ardent::$customMessages )
Array yang tidak kosong akan mengesampingkan aturan atau pesan kesalahan khusus yang ditentukan oleh kelas untuk instance metode tersebut saja.
Catatan: nilai default untuk
$rulesdan$customMessagesadalaharray()kosong; jadi, jika Anda meneruskanarray()tidak ada yang akan diganti.
Sama seperti Laravel Validator, Ardent memungkinkan Anda mengatur pesan kesalahan khusus menggunakan sintaks yang sama.
class Pengguna extends LaravelArdentArdentArdent { public static $customMessages = array('required' => 'Bidang :attribute wajib diisi.',
...
);
}Anda dapat membuat aturan validasi khusus dengan cara yang sama seperti yang Anda lakukan untuk Laravel Validator.
Ardent memberikan beberapa gula sintaksis pada acara model Eloquent: pengait model tradisional. Ini adalah cara mudah untuk menghubungkan operasi tambahan ke momen berbeda dalam kehidupan model Anda. Mereka dapat digunakan untuk melakukan pekerjaan pembersihan tambahan sebelum menghapus entri, melakukan perbaikan otomatis setelah validasi terjadi, atau memperbarui model terkait setelah pembaruan terjadi.
Semua before hook, ketika mengembalikan nilai false (khususnya boolean, bukan sekadar nilai "falsy") akan menghentikan operasi. Jadi, misalnya, jika Anda ingin berhenti menyimpan jika terjadi kesalahan dalam metode beforeSave , return false dan penyimpanan tidak akan terjadi - dan jelas afterSave tidak akan dipanggil juga.
Berikut daftar lengkap hook yang tersedia:
before / afterCreate()
before / afterSave()
before / afterUpdate()
before / afterDelete()
before / afterValidate() - ketika mengembalikan false akan menghentikan validasi, sehingga membuat operasi save() juga gagal karena validasi gagal.
Misalnya, Anda dapat menggunakan beforeSave untuk melakukan hashing pada kata sandi pengguna (sebenarnya, akan lebih baik jika menggunakan hashing otomatis!):
class User extends LaravelArdentArdentArdent { public function beforeSave() {// jika ada kata sandi baru, hash itif($this->isDirty('password')) { $this->password = Hash::make($this->password );
} return true;//atau jangan mengembalikan apa pun, karena hanya boolean false yang akan menghentikan operasi
}
} beforeSave dan afterSave dapat disertakan pada saat run-time. Cukup teruskan penutupan dengan model sebagai argumen ke metode save() (atau forceSave() ).
$user->save(array(), array(), array(), function ($model) { // penutupan untuk beforeSaveecho "menyimpan objek model...";return true;
}, function ($model) { // penutupan untuk afterSaveecho "selesai!";
}
);Catatan: penutupan harus memiliki satu parameter karena akan meneruskan referensi ke model yang disimpan.
Pernahkah Anda menulis model Eloquent dengan banyak relasi, hanya untuk menyadari betapa berantakannya kelas Anda, dengan semua kalimat yang memiliki konten hampir sama dengan nama metode itu sendiri?
Di Ardent Anda dapat dengan jelas mendefinisikan hubungan Anda dalam array dengan informasinya, dan hubungan tersebut akan berfungsi seperti jika Anda mendefinisikannya dalam metode. Berikut ini contohnya:
kelas Pengguna extends LaravelArdentArdentArdent { public static $relationsData = array('address' => array(self::HAS_ONE, 'Address'),'orders' => array(self::HAS_MANY, 'Order'),'groups' = > array(mandiri::BELONGS_TO_MANY, 'Grup', 'tabel' => 'grup_memiliki_pengguna')
);
}$pengguna = Pengguna::find($id);echo "{$pengguna->alamat->jalan}, {$pengguna->alamat->kota} - {$pengguna->alamat->negara bagian}";Sintaks arraynya adalah sebagai berikut:
Nilai indeks pertama: nama relasi, menjadi salah satu dari hasOne , hasMany , belongsTo , belongsToMany , morphTo , morphOne , morphMany , atau salah satu konstanta terkait ( Ardent::HAS_MANY atau Ardent::MORPH_ONE misalnya).
Terindeks kedua: nama kelas, dengan namespace lengkap. Pengecualiannya adalah relasi morphTo , yang tidak memerlukan argumen tambahan.
argumen bernama, mengikuti argumen yang ditentukan untuk metode Eloquent asli:
foreignKey [opsional], berlaku untuk hasOne , hasMany , belongsTo dan belongsToMany
table , otherKey [opsional], timestamps [boolean, opsional], dan pivotKeys [array, opsional], valid untuk belongsToMany
name , type dan id , digunakan oleh morphTo , morphOne dan morphMany (dua yang terakhir memerlukan name untuk didefinisikan)
Catatan: Fitur ini didasarkan pada relasi mudah pada Yii 1.1 ActiveRecord.
Ardent mampu menghidrasi kelas model entitas Anda dari pengiriman masukan formulir secara otomatis!
Mari kita lihat aksinya. Pertimbangkan cuplikan kode ini:
$pengguna = Pengguna baru;$pengguna->nama = Input::get('nama');$pengguna->email = Input::get('email');$pengguna->kata sandi = Hash::make(Input ::dapatkan('kata sandi'));$pengguna->simpan();Mari kita gunakan keajaiban Ardent dan menulis ulang cuplikan sebelumnya:
$pengguna = Pengguna baru;$pengguna->simpan();
Itu saja! Yang kami lakukan hanyalah menghilangkan hal-hal yang membosankan.
Percaya atau tidak, kode di atas pada dasarnya melakukan tugas yang sama dengan kode yang lebih tua, meskipun agak bertele-tele. Ardent mengisi objek model dengan atribut dari data formulir yang dikirimkan pengguna. Tidak perlu lagi repot-repot mencari tahu properti Eloquent mana yang lupa Anda isi. Biarkan Ardent mengurus hal-hal membosankan, sementara Anda melanjutkan hal-hal menyenangkan!
Ini mengikuti aturan penugasan massal yang sama secara internal, bergantung pada properti $fillable / $guarded .
Untuk mengaktifkan fitur hidrasi otomatis, cukup setel variabel instan $autoHydrateEntityFromInput ke true di kelas model Anda. Namun, untuk mencegah pengisian properti yang sudah ada sebelumnya, jika Anda ingin hidrasi otomatis juga untuk skenario pembaruan, Anda harus menggunakan $forceEntityHydrationFromInput :
kelas Pengguna extends LaravelArdentArdentArdent { public $autoHydrateEntityFromInput = true; // menghidrasi validasi entri baru
publik $forceEntityHydrationFromInput = benar; // terhidrasi setiap kali validasi dipanggil} Model Ardent dapat secara otomatis membersihkan data masukan yang berlebihan (seperti konfirmasi kata sandi , _token CSRF tersembunyi, atau bidang _method _HTTP khusus) - sehingga data tambahan tidak pernah disimpan ke database. Ardent akan menggunakan kolom konfirmasi untuk memvalidasi input formulir, lalu dengan hati-hati membuang atribut ini sebelum menyimpan instance model ke database!
Untuk mengaktifkan fitur ini, cukup setel variabel instance $autoPurgeRedundantAttributes ke true di kelas model Anda:
kelas Pengguna extends LaravelArdentArdentArdent { public $autoPurgeRedundantAttributes = true;
} Anda juga dapat membersihkan kolom tambahan. Atribut Ardent::$purgeFilters adalah array penutupan tempat Anda dapat menambahkan aturan khusus. Penutupan tersebut menerima kunci atribut sebagai argumen dan harus mengembalikan false untuk atribut yang harus dibersihkan. Seperti ini:
fungsi __construct($attributes = array()) { parent::__construct($attributes); $this->purgeFilters[] = function($key) {$purge = array('tempData', 'myAttribute');return ! in_array($kunci, $pembersihan);
};
} Misalkan Anda memiliki atribut bernama password di kelas model Anda, tetapi tidak ingin menyimpan versi teks biasa di database. Hal pragmatis yang harus dilakukan adalah menyimpan hash dari konten asli. Jangan khawatir, Ardent sepenuhnya mampu melakukan transmogrifikasi sejumlah bidang aman secara otomatis untuk Anda!
Untuk melakukannya, tambahkan nama atribut ke variabel array statis Ardent::$passwordAttributes di kelas model Anda, dan atur variabel instan $autoHashPasswordAttributes ke true :
kelas Pengguna extends LaravelArdentArdentArdent { public static $passwordAttributes = array('password'); publik $autoHashPasswordAttributes = benar;
} Ardent akan secara otomatis mengganti atribut kata sandi teks biasa dengan checksum hash aman dan menyimpannya ke database. Ia menggunakan metode Laravel Hash::make() secara internal untuk menghasilkan hash. Catatan: Disarankan untuk menggunakan atribut $hidden Eloquent sehingga kata sandi, meskipun di-hash, tidak akan keluar dengan mudah jika Anda membuat API atau sejenisnya :)
Jika Anda menggunakan Ardent mandiri, Anda dapat menggunakan Ardent::$hasher untuk memverifikasi nilai bidang, menggunakan sesuatu seperti User::$hasher->check($given_password, $user->password) .
Ardent dapat membantu Anda dengan pembaruan unik. Menurut Dokumentasi Laravel, ketika Anda memperbarui (dan memvalidasi) bidang dengan aturan unik, Anda harus memasukkan ID unik dari catatan yang Anda perbarui. Tanpa meneruskan ID ini, validasi akan gagal karena Validator Laravel akan menganggap catatan ini adalah duplikat.
Dari Dokumentasi Laravel:
'email' => 'unik:pengguna,email,10'
Di masa lalu, pemrogram harus mengelola penerusan ID secara manual dan mengubah kumpulan aturan untuk menyertakan ID saat runtime. Tidak demikian halnya dengan Ardent. Cukup siapkan aturan Anda dengan unique , panggil fungsi updateUniques dan Ardent akan mengurus sisanya.
Dalam model yang diperluas, tentukan aturan Anda
public static $rules = array( 'email' => 'wajib|email|unik', 'kata sandi' => 'wajib|antara:4,20|dikonfirmasi', 'konfirmasi_kata sandi' => 'antara:4,20', );
Di pengontrol Anda, saat Anda perlu memperbarui, cukup panggil
$model->updateUniques();
Jika diperlukan, Anda dapat meneruskan aturan runtime ke updateUniques , jika tidak maka aturan statis yang disediakan oleh model Anda akan digunakan.
Perhatikan bahwa dalam contoh aturan di atas, kami tidak memberi tahu Validator tabel mana atau bahkan bidang mana yang akan digunakan seperti yang dijelaskan dalam Dokumentasi Laravel (yaitu unique:users,email,10 ). Ardent cukup pintar untuk mengetahuinya. (Terima kasih kepada pengguna github @Sylph)
