تذکر: این یک پست آموزشی برای عموم نیست! بلکه تنها جایی برای یادداشتهای من حین یادگیریه تا بهتر به خاطر بسپارم و در صورت لزوم به اونها مراجعه کنم.
قسمت ۶۰ تا ۷۰
این مفهوم به ما کمک می کنه تا کار با seeder راحتتر بشه، منظور از factory یک کارخونه هست که برای ما اطلاعات fake ایجاد میکنه. مسیرش هم که مشخصه، توی database و پوشهٔ factories قرار گرفته و یک فایل default داخلش داریم به اسم UserFactory.php، حالا ما به راحتی میتونیم برای جداول خودمون factory ایجاد کنیم.
نحوه ایجاد یک factory:
php artisan make:factory ArticleFactory --model=Article
نکتهٔ مهم در مورد factory اینه که اینها با مدل ها کار میکنن و قبل از ایجاد یک فکتوری باید مدل متناظرش رو ایجاد کرده باشیم. artisan این فایل رو توی پوشهٔ factories برای ما ایجاد میکنه و مدل به همراه Faker رو use میکنه و ما کافیه که توی بدنهٔ return مقادیری که قراره توی table قرار بگیره رو وارد کنیم:

نحوهٔ استفاده از factory هم به این شکله که لاراول برای اون یک helper function قرار داده به اسم factory که هر جایی که نیاز داشتیم میتونیم ازش استفاده کنیم و این قضیه مزیت factory نسبت به seeder هست چون seeder حتما باید داخل CLI ران بشه، اما factory خیر، مثلا خیلی راحت میتونیم این تابع رو توی controllerهای خودمون کال کنیم:
$times_to_create = 15; factory(Article::class, $times_to_create)->create();
حتی میتونیم فکتوری بالا رو (یعنی تابع) رو توی متد run یک seeder فراخوانی کنیم.
۱- روابط یک به یک (one to one):
به عنوان مثال، توی یک سایت هر کاربری یک پروفایل دارد و هر پروفایلی متعلق به یک کاربر هست پس روابط میان جدول users و profiles از نوع one to one خواهد بود. ارتباط میان جداول از طریق foreign key برقرار میشود. الان توی تصویر زیر، در جدول profiles یک فیلد داریم به اسم user_id که foreign key ما محسوب میشود.

برای برقراری ارتباط یک به یک بین users و profiles باید مدل و migration اونها رو بسازیم. خود لاراول به صورت دیفالت user رو داره، پس باید مدل و migration مربوط به Profile (دقت به اسم: سینگل، upper) رو بسازیم:
php artisan make:model Profile -m
و migration اون رو ردیف میکنیم و فیلدهای table رو میسازیم. نکتهٔ مهم نحوهٔ ایجاد foreign key در migration هست؛ نوع یا data type کلید خارجی جدول ما باید با id جدول اولیه یکی باشه، یعنی اگر id از نوع bigIncrement هست؛ foreign key هم باید از نوع BigInteger باشه:

توی تصویر بالا از onDelete و onUpdate هم میتونیم استفاده کنیم و بهش آرگومان cascade رو بدیم.
حالا میتونیم migrate بزنیم.
خب در ادامهٔ کار (مطابق تصویر زیر) یک شی به نام $user از مدل User ایجاد کردیم که روش متد find رو فراخوانی کردیم تا user با id یک رو برای ما برگردونه، بعدش متد profile از شی user رو صدا زدیم؛ طبیعتا وقتی یک چنین کاری میکنیم؛ مدل ما باید یک متد با نام profile داشته باشه که در قسمت پایین به تصویر کشیده میشه:

توی تصویر زیر متد profile رو توی متد مدل User تعریف کردیم:

خب توی تصویر بالا، یک متد به نام profile داخل مدل User.php تعریف کردیم و با $this که اشاره داره به کلاس مدل ما، یک متد به نام hasOne رو فراخوانی کردیم و به عنوان پارامتر ورودی بهش Profile::class رو دادیم که در واقع مدل Profile ما هست. اینجا داریم میگیم که هر user یک پروفایل داره و اینطوری ارتباطه برقرار میشه. و یک سینتکس جایگزین هم برای Profile::class داریم اونم مقداری هست که همین عبارت برگشت میده، یعنی:
'App\Models\Profile'
دقیقا میتونیم برعکس این عملیات رو هم برای مدل Profile اجرا کنیم. با این تفاوت که توی مدل Profile باید از متد belongsTo استفاده کنیم؛ یعنی اینکه این profile مربوطه به فلان user:

اساس کار این رابطه id و user_id یعنی پرایمری و کلید خارجی هست. اما نکتهٔ مهم اینه که لاراول چطوری میفهمه که user_id چی هست؟ لاراول براساس اسم جدول این عملیات رو انجام میده یعنی اینکه چون ما یه جدول داریم به اسم users، میاد مفردش میکنه و تهش یه _id میذاره و به اون مقدار فیلد دسترسی پیدا میکنه، اما اگر ما یک فیلد دیگه رو به عنوان foreign key تعریف کنیم باید اسمش رو به عنوان پارامتر به متدهایی مثل hasOne پاس بدیم:

توی مدل Profile هم دقیقا میتونیم همین عملیات رو انجام بدیم:

۱- روابط یک به چند (one to many):
در این نوع از روابط یک مدل واحد با چندین مدل دیگر در ارتباط است.
مثال: رابطه میان پستهای یک وبلاگ و کامنتهای آن. هر پست چندین کامنت داره، اما هر کامنت، فقط و فقط متعلق به یک پست خاصه.

نحوهٔ پیادهسازی در لاراول:


توی جدول comments اومدیم و post_id رو به عنوان کلید خارجی تعریف کردیم.
خب برای دسترسی به کامنتهای یک پست، اول نیاز داریم که اون پست خاص رو پیدا کنیم؛ این کار رو میتونیم توی کنترلر انجام بدیم و با استفاده از مدل Post و متدی مثل find پست با id یک رو پیدا کنیم:
$post = Post::find(1);
حالا برای پیدا کردن کامنتهای این پست از جدول comments توی دیتابیس، باید متد comments رو از مدل Post فراخوانی کنیم:
$comments = $post->comments;
نحوهٔ پیادهسازی متد comments هم به شکل زیر در کنترلر Post هست:

خیلی ساده میتونیم روی متد comments هم کوئری بزنیم:
$comments = $post->comments->where('is_status', 1);
بریم برای رابطهٔ معکوس، یعنی چک کنیم؛ ببینیم که فلان کامنت برای کدوم پسته:
$comment = Comment::find(1); $post = $comment->post;
حالا باید متد post رو توی مدل Comment تعریف کنیم:

نحوهٔ پاس دادن foreign key (اگر کلید خارجی نام متفاوتی داشت):

توی تصویر بالا یک نکتهٔ ظریف وجود داره و اونم local_key هست که به صورت دیفالت id هست. از اونجایی که توی این رابطه، کامنتها با استفاده از post_id به id مدل Post وصل شدن، پس id که اینجا تعریف شده (داخل مدل Post)، لوکال نامیده میشه (متعلق به خودشه).
۳- رابطهٔ Many to Many:
مثال:
فرض کنیم که یک table داریم به اسم users که توش کاربران مختلفی تعریف شدن و یک جدول داریم به اسم roles که نقشهای مختلفی برای کاربران تعریف شده، مثلا admin و نویسنده و ناظر و... خب، هر کاربری می تونه چندین role داشته باشه و هر role میتونه متعلق به چندین کاربر باشه، این نوع رابطه رو بهش میگیم چند به چند:

تفاوت این رابطه، با روابطی که تا الان کار کردیم در اینه که ما نمی تونیم توی جدول role کلید خارجی تعریف کنیم؛ چرا که با این کار، هر role رو فقط به یک کاربر اختصاص می دیم؛ ما نیاز داریم که یک نقش رو به چند کاربر بدیم و برعکس، برای حل این مشکل باید از جدول رابط یا pivot table استفاده کنیم؛ که نقش محور یا رابط رو بین دو تا جدول اصلی ما به عهده میگیره:
نکتهٔ مهم در ایجاد pivot table نامگذاری اون هست که طبق استاندارد لاراول، ترکیبی مفرد از اسامی دو تا جدولی هست که قراره با هم relation داشته باشند و این اسم ترکیبی براساس حروف الفبا هست؛ یعنی چون r زودتر از u میاد اسم جدول میشه role_user:

توی pivot table میگیم که مثلا یک user با user_id یک، role_id فلان رو داره، حالا اگر همین کاربر یک نقش دیگهای هم داشت؛ یک ریکورد دیگه هم به همین pivot table اضافه خواهیم کرد.
تصویری از role_user migration:

ما برای انجام این عملیات، نیازی به مدل role_user نداریم و فقط به migration اون نیاز داریم.
باید دقت کنیم که هر دو تا attribute از نوع primary و unique هستند.
توی تصویر زیر، میخوایم ببینیم که چطوری میشه نقشهای مختلف یک user رو پیدا کرد، در واقع اینجا شروع کاره و تصاویر بعدی، قسمتهای مختلف این ارتباط رو نشون خواهد داد:

متد roles در مدل User:

توی کنترلر که متد roles یا به عبارت درستتر، رابطهٔ roles رو که فراخوانی کردیم؛ میتونیم از طریق اون به جدول pivot هم دسترسی داشته باشیم:
$user = User::find(1) $roles = $user->roles->first(); $roles->pivot;
توی کد بالا، حتما باید متد first() رو روی رابطهٔ خودمون اجرا کنیم؛ وگرنه امکان دسترسی به pivot وجود نداره. هم چنین، وقتی table پیوت برمی گرده، فقط ستونهای اصلی ما یعنی role_id و user_id برگشت داده میشه و به ستونهای updated_at و created_at دسترسی نداریم؛ برای دسترسی به این ها باید توی متد roles توی مدل User تغییراتی ایجاد کنیم:

برای برگردوندن سایر فیلدها هم میتونیم از دستور زیر استفاده کنیم:

حتی یک دستور شرطی مربوط به Pivot table هم داریم:
return $this->belongsToMany(Role::class)->wherePivot('is_status', 1);
ارتباط معکوس در رابطهٔ Many to Many:
یعنی چی؟ یعنی اینکه ما یک role داریم؛ میخوایم چک کنیم که کدام یک از userهای ما این role رو دارن:

حالا می تونی داخل مثلا یک کنترلر، چک کنیم که فلان role، مربوط به کدوم userها میشه:

آرگومانهای مربوط به متد belongsToMany:
return $this->belongsToMany(Role::class, 'pivot_table', 'local_foreign_key', 'other_foreign_key', 'local_id', 'other_id');
مبحث وارد کردن دیتا به جدول Pivot:
این بحث خیلی مهمه، ما مدلی برای Pivot table نداریم و در قسمت بالا هم گفتیم که فقط یک migration برای این جدول ایجاد کردیم؛ حالا چطور بهش دیتا وارد کنیم؟
در اینجا دو تا متد بسیار مهم save و attach وارد عمل میشن:
توی مثال زیر، ما قصد داریم که role شماره ۱ رو بدیم به user شماره ۲:
// find role number one $role = Role::find(1); // find user number one: $user = User::find(2); // giving the user 2, the role number 1 $result = $user->roles()->save($role); // the method, attach is exact like the save method: $result = $user->roles()->attach($role);
برای برداشتن سطح دسترسی خاصی از یک user از دستور زیر استفاده میشه:
$result = $user->roles()->detach($role);
نهایتا دستور کاربردی بعدی، دستور sync هست؛ این دستور میاد تمامی roleهای یک کاربر رو پاک میکنه و roleهای جدیدیی که بهش دادیم رو روی کاربر ست میکنه:
$result = $user->roles()->sync($role);
حالا میتونیم کاری کنیم که sync رولهای قبلی رو پاک نکنه و فقط مثل save یا attach عمل کنه (باید دقت کنیم که مقدار برگشتی این متدها در صورت درست اجرا شدن کمی متفاوته، مثلا اتچ اگر درست اعمال بشه، null برمیگردونه):
$result = $user->roles()->sync($role, false);
۴- رابطهٔ Has One Through
یک رابطهٔ یک با یک با این تفاوت که برای پیادهسازی آن از یک جدول واسط استفاده میشود:
مثال برای درک بهتر:

توی مثال بالا، هر user فقط یک ماشین داره (رابطه یک به یک)، یک جدول رابط داریم به اسم cars_info که اطلاعات منحصر به فرد ماشینها در این جدول قرار گرفته، به عبارت دیگه، هر ماشینی توی cars_info یک سطر رو اشغال کرده (رابطه یک به یک).
قصد ما توی این رابطه اینه که با داشتن یک کاربر (مثلا کاربر شماره ۱)، اطلاعات ماشین اون کاربر رو به دست بیاریم. اما از اونجایی توی cars_info فیلد user_id تعریف نشده، پس نمی تونیم مستقیم به اطلاعات ماشین اون user دسترسی پیدا کنیم. بنابراین باید از car_id استفاده کنیم.
پیادهسازی این رابطه:



برای تمامی اینها مدل هم داریم.
خب، بریم توی یکی از کنترلرها برای پیادهسازی این رابطه:
$user = User::find(1); $car_info = $user->CarInfo;
خب، پس باید یک متد با نام CarInfo بنویسیم و توی مدل User قرار بدیم:
public function carInfo(){ return $this->hasOneThrough(CarInfo::class, Car); }
به این شکل رابطه رو برقرار کردیم.
سایر پارامترهای متد hasOneThrough:

پارامتر اول، اسم فیلد کلید خارجی جدول واسط
پارامتر دوم، اسم فیلد کلید خارجی جدول نهایی
پارامتر سوم، کلید اصلی جدول اولیه
پارامتر چهارم، کلید اصلی جدول دوم (واسط، در اینجا cars).
۵- رابطهٔ Has Many Through:
یک رابطهٔ یک به چند، اما با یک جدول واسط:

توی رابطهٔ بالا، جدول users جدول واسط ما هست بین posts و countries، در واقع ما میخوایم پست های کاربران مربوط به یک کشور خاص رو پیدا کنیم. چون کاربران یک کشور میتونند چندین پست داشته باشن، از طرفی هر پست متعلق به کاربر یک کشور هست به این اسم نام گذاری شده.
ما به سه مدل و سه migration برای Country Post و User نیاز داریم.
توی شکل بالا، ما از سمت راست یعنی جدول countries میخوایم برسیم به جدول posts و از جدول users به عنوان واسط استفاده میکنیم.
تصور کنید، کشور ایران، ۱۰۰ تا user داره و هر کدوم از این userها میتونن چندین پست داشته باشند. پس ما میتونیم از طریق اسم کشور به پستهای مربوط به یک کشور خاص دست پیدا کنیم. اما پیادهسازی این relation در لاراول:
$country = Country::find(1); $posts = $country->posts;
تعریف متد posts در مدل country:

خب، توی تصویر بالا، داخل کنترلر Country، یک متد posts تعریف کردیم و داخلش یک رابطه رو برگشت دادیم، گفتیم که مدل Country از طریق جدول users به یک سری پستهایی دسترسی دارد.
متد hasManyThrough دو تا آرگومان داره، اولی جدول نهایی و دومی، جدول واسط.
۶- روابط پلی مورفیک
در این روابط یک مدل میتونه همزمان به چند مدل دیگه تعلق داشته باشه، مثلا یک جدول برای پستهامون داریم و یک جدول هم برای کامنتها، یک پست ممکنه چندین کامنت داشته باشه و بنابراین باید یک کلید خارجی به اسم post_id بهش تعلق بگیره، توی این سناریوی که الان گفتیم؛ یک مدل فقط به یک مدل وصله، حالا تصور کنید که یک جدول داشته باشیم برای محصولات (products) خودمون، و کاربرها میتونن برای این محصولات هم نظر بذارن، اگر قرار باشه به شکل قدیمی و بدون استفاده از روابط پلیمورفیک عمل کنیم؛ باید یک جدول comments هم برای products ایجاد کنیم و یک product_id براش ست کنیم که حرکت جالبی نیست.
حالا فرض کنید جدول های دیگه هم داشته باشیم که نیاز به کامنت داشته باشن، بنابراین روابط پلی مورفیک میان و این مشکل رو برای ما حل میکنن، یک جدول میتونه به بینهایت جدول دیگه وصل بشه.
۶-۱- روابط پلیمورفیک یک به یک (one to one):
در این نوع روابط که مشابه روابط یک به یک معمولی هستن، اما یک تفاوت مهم وجود داره و اونم اینه که مدل مقصد تنها به یک مدل مبدا یا اولیه وابسته نیست.
مثال:

خب، توی تصویر بالا، جدول images جدول مقصد ما هست که به دو تا جدول مبدا متصل شده، جدول posts و جدول products، ما ممکنه کلی جدول داشته باشیم که نیاز باشه عکسهاشون یا نظراتشون رو توی یک جدولی جا بدیم، بنابراین از این نوع رابطه استفاده میکنیم؛ اما نکتهٔ مهم در جدول مقصد اینه که دو تا فیلد داره یکی به اسم imageable_id و دیگر imageable_type که توی id، آیدی جداول مبدا برای اون ریکورد خاص قرار میگیره و توی imageable_type، مدل مربوط به اون جدول مثلا App\Models\Post که مشخص میکنه که این مربوط به چه مدل/جدولی هست.
نمایی از جدول images در دیتایس:

خب، توی تصویر زیر، یه کنترلر داریم و اونجا با استفاده از مدل Post به دنبال یک پستی گشتیم و میخواستیم ببینیم که عکس مربوط به اون توی جدول images چیه:

مایگریشنهای مربوط به Post و Product که چیز خاصی نداره، اما برای Image:

توی تصویر بالا، خطی که هایلایت شده، فیلدهای imageable_type و imageable_id رو برای ما ایجاد میکنه.
خب، ما باید توی مدل جدول مقصد یعنی Image یک متد از نوع polymorphic تعریف کنیم:

حالا باید رابطهٔ بالا رو توی مدل های Post و Product کامل کنیم؛ نحوه برقراری ارتباط مدل Post با مدل Image:

توی تصویر بالا، متد حتما باید از نوع مفرد باشه (مثل image)، و یک رابطه پلیمورفیک از نوع یک به یک رو برمیگردونه، پارامتر اول، مدلی هست که باهاش مرتبطه و پارامتر دوم، اسم متدی هست که بهش وصله.
عینا همین کار رو توی product انجام میدیم:

توی این رابطهٔ یک به یک، دقیقا عکس قضیه هم صادقه هم میشه مثلا گفت، فلان تصویر مربوط به چه مدل/جدولی میشه:
$image = Image::find(3); $image->imageable;
داخل مدل Image، جایی که رابطهٔ پلی مورفیک ایجاد شده، آرگومان خاص و اضافهتری نیاز نداریم؛ اما میتونیم توی Post و Product برای رابطهٔ خودمون یک سری آرگومان اضافه، بسته به نیاز داشته باشیم:

آرگومانها:
۱- اسم مدلی که قراره باهاش رابطه برقرار بشه
۲- اسم رابطهٔ پلیمورفیک
۳- tableable_type
۴- tableable_id
۵- id مدلی که رابطه توش نوشته میشه (در اینجا Post).
نحوه وارد کردن دیتا به جدول images در روابط پلیمورفیک:

یک نکته اینکه باید دقت کنیم که fillable رو اوکی کنیم؛ چون داریم mass assign انجام میدیم.
نحوهٔ آپدیت کردن:

نحوهٔ Delete:

۶-۲- رابطهٔ یک به چند در پلیمورفیک
توی این تصویر یک نمای کلی از این نوع رابطه رو میبینیم که دو تا جدول داریم به اسمهای photos و videos که هر کدوم ممکنه چندین کامنت داشته باشن، یعنی هر پستی ممکنه چندین کامنت داشته باشه، اما هم کامنتی فقط و فقط به یک پست متعلقه:

نمایی از جدول comments توی دیتابیس:

نمایی از migration مربوط به comments:

خب، طبق معمول بریم سراغ کنترلر و تا به مقادیری که می خوایم از مدل بکشیم بیرون دسترسی داشته باشیم:

حالا باید رابطهٔ پلیمورفیک رو توی مدل Comment ایجاد کنیم:

حالا بریم سراغ مدل های Post و Video برای کامل کردن رابطهٔ پلیمورفیک:

اینجا میتونیم خروجی درخواست خودمون در HomeController رو ببینیم:

مباحث دقیقا برای Video هم همونه! پس دیگه چیزی اضافه نمیکنیم.
۶-۳- رابطهٔ چند به چند پلی مورفیک:
توی مثال زیر، پستها و ویدئوهای ما میتونه در چندین category قرار بگیره و هر category هم چندین پست و video داره:

توی روابط Many to Many معمولی، از یک جدول واسطه به اسم Pivot table استفاده میکردیم که جریان داده به این شکل میشد، از پستها به رابطه و از رابطه به دستهبندیها، اینجا هم همین جدول رو داریم به اسم categorizables.
اینجا category_id کلید خارجی جدول categories هست.
نمایی از جدول categorizables:

مایگریشن جدول categorizables:

توی این جدول id و timestamps رو نداریم.
دوباره مباحث تکراری هست و مشابه موارد قبل، می دونیم که چطور باید روابط رو برقرار کنیم و فقط سریع با اسکرینشات و بدون توضیح اضافه ازشون عبور میکنیم:
دسترسی به کتگوری های یک پست داخل کنترلر:

برقراری رابطه در مدل Post:

دقیقا همین متد توی همهٔ مدل های مبدا قابل استفاده هست.
آرگومانهای مربوط به متد morphToMany:
۱- نام مدلی که قراره باهاش رابطه برقرار کنیم
۲- نام رابطهٔ پلی مورفیک ما
۳- اسم جدول واسط (categorizables)
۴- کلید خارجی مدل مقصد (category_id)
۵- کلید خارجی مدلهای مبدا (categorizable_id)
۶- کلید اصلی مدلی که در اون رابطه رو مینویسیم (id)
۷- کلید اصلی مدل مقصد (id)
۸- اگر true باشد، رابطه معکوس میشود
این آرگومانهای توی اسکرینشات پایین مشخص هستن:

حالا بریم سراغ اینکه با انتخاب یک Category خاص، به پستها و ویدئوهاش دسترسی پیدا کنیم:

برای برقراری ارتباط بالا، باید متدهای posts و videos رو توی مدل Category تعریف کنیم:

چهار عمل اصلی در روابط Many to Many:



