הרשאות לפי משתמשים - Users & Roles
להורדת קוד מקור של כל הדוגמאות בקורס MVC – לחץ כאן
פרקי ההרצאה: הרשאות לפי משתמשים - Users & Roles
תמלול ההרצאה: הרשאות לפי משתמשים - Users & Roles
הטקסט המלא של הדקות הראשונות בהרצאה «הרשאות לפי משתמשים - Users & Roles» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אוקיי, מה שאנחנו הולכים לראות עכשיו זה נושא ה-Roles ב-Security. אחרי שאנחנו ראינו איך אנחנו יכולים למנוע גישה לדפים רק אם בן אדם נרשם לאתר, אנחנו הולכים להרחיב את זה ולהראות איך אנחנו יכולים לאפשר גישה כתלות בתפקיד מסוים שאנחנו מגבירים עבור המשתמש.
אנחנו הולכים לעשות את זה על Visual Studio 2010 רק בכדי להראות שגם אם יש לכם Visual Studio 2010 זה ניתן לביצוע, VC יכולה לרוץ על זה והכל ממש זהה לדוגמאות האחרות שביטלנו ב-2012.
אבל בואו נבין רגע מה זה אומר רולי ולמה חשוב לנו לדעת את זה. אז יש לנו פה דוגמה מוכנה שאנחנו יכולים לראות דומה למה שעשינו בעבר.
אם אנחנו מריצים אותה אנחנו יכולים לראות שיש לנו דף פאי ואנחנו רואים שיש לנו פה אפשרות לנהל את המוצרים בטבלת product ומסד הנתונים מיופניים.
אנחנו רואים שיש לנו פה אפשרות כניסה לדף בית, יש לנו פה Hello Guest, אנחנו יכולים לבצע Login, וכרגע כל האפשרויות יכולות להתבצע על ידי יוזרים פשוטים.
לדוגמה, אני הולך ל-View All Products, ואני רואה את כל המוצרים שיש במיופניים. עכשיו, אם אני נכנס ל-Create New Product, אז המערכת מאפשרת לי כרגע ליצור מוצר, גם אם לא נרשמתי להשתמש פשוט, ואת זה אנחנו רוצים למנוע.
אנחנו רוצים להגיד, רק אם משתמש קודם כל נרשם במערכת וביצע לוגין, אז רק הוא יוכל לבצע הוספת מוצר חדש, כאשר כרגע זה לא מאופשר, תכף אנחנו הולכים לטפל בזה. אז בואו ניצור איזשהו מוצר, נניח במבה שעולה 3.5. נבצע קריייט ונראה פה למטה את במבה.
עכשיו בואו נראה אם אנחנו יכולים לבצע אדיט. ניכנס, ושימו לב שאנחנו עדיין על גסט, כלומר לא נרשמנו במערכת ואנחנו מסוגלים לערוך את באמבה ובמקום שלוש וחצי הייתה העלאה לארבע נקודה שבע בואו נבצע אפדייט והמערכת אישרה לנו עכשיו אם אנחנו רוצים למחוק את המוצר בואו נבצע גילית אנחנו רואים שהגענו לדף
הזה לבצע גילית המערכת אישרה לנו למחוק את המוצר מה אנחנו הולכים לשפר בדוגמה הזו מעבר לעובדה שאנחנו הולכים לבצע אישור צפייה במוצרים רק אם אתה לבצע את הלוגעים מסוים רק אם היוזר ביצע לוגעים אנחנו רוצים לאפשר עוד כמה דברים אנחנו רוצים לדוגמה לאפשר דבר כזה רק אם הלקוח הוא מנהל אנחנו יכולים לאפשר או לבצע
עריכה או מחיקה של מוצר בוא נגיד אפילו דבר כזה רק אם היוזר הוא מנהל אנחנו רוצים לבצע אפשרות להוספת מוצר ולעריכת מוצר בשביל מחיקה אפילו בואו נרחיק ונגיד שרק אם היוזר הוא בתפקיד אדמיניסטרטור רק אז הוא יוכל לבצע מחיקה של מוצר.
בנוסף אנחנו רוצים לאפשר למערכת לנהל את אותם פקידים, אותם roles ומי שיוכל לנהל אותם כמובן זה רק אדמיניסטרטור, לא הגיוני שיוזר פשוט יוכל להגדיר את עצמו כאדמיניסטרטור, רק אדמיניסטרטור יוכל להגדיר יוזר אחר כמנהל, כמסבירה או כאדמיניסטרטור.
זאת אומרת כל הקונספט הזה של איך אנחנו יכולים לנהל את המערכת על ידי roles, על ידי תפקידים שונים של היוזר, אנחנו הולכים להלביש על הקוד הנוכחי שבנינו כאן. עכשיו, לפני שנתחיל בואו נסתכל רגע על התוכנית המוכנה הזאת, נראה איזה מרכיבים יש לנו כאן. אז אנחנו רואים שיש לנו פה שני פרויקטים בסלושן, יש לנו business logic,
כמובן יש לנו פה face logic, יש לנו כאן את כובד ה-edmx של entity framework, יש לנו product logic לניהול כל המוצרים, אנחנו רואים פה אפשרות לקבלת כל המוצרים, קבלת מוצר אחד, יש לנו פה אפשרות לבצע הוספת מוצר, עדכון מוצר קיים ומחיקת מוצר.
זה מבחינת הביזנס לוג'יק מודל שכבון. בנוסף, יש לנו פה אפשרות לבצע פעולות על יוזרים. הפעולות שיש לנו אפשרות לעשות על יוזרים הן רישום יוזר חדש, שמאפשר להביא יוזרנר ופספורט ולהירשם למערכת, בדיקה האם שם משתמש כבר תפוס למעשה, מחלקה האם היוזר קיים לפי יוזרים ותאסרות וקבלת
כל היוזר. אלה הפעולות שאנחנו יכולים לבצע על המשתמשים. יש לנו כאן גם מחלקה שמטפלת בכל התפקידים. כאן אנחנו יכולים לראות שיש לנו פה המון פעולות שאנחנו יכולים לבצע על תפקידים שונים שקיימים במערכת אבל בשביל להבין את הפעולות האלה בואו נלך ונראה איך הגדרנו
את מסד הנתינים. יש לנו כאן אפשרות לראות את ה-database של נורפינג ואנחנו יכולים לראות בעצם קובץ SQL שבניתי במיוחד בשביל הקונספט של roles עבור אתר mvc.
ומה שאנחנו רואים כאן זה בעצם יצירה של טבלה שנקראת roles, והטבלה הזאת היא מאוד פשוטה, יש לה מפתח שזה מספור אוטומטי ראפס, אנחנו רואים את ה-identity, יש לה role name, שם התפקיד, האם אתה אדמיניסטרטור, האם אתה מנהל, האם אתה יוזר פשוט, האם אתה מזכירה, זה התפקיד עצמו, השם שלו.
כמובן הוא יוניק, לא יכול להיות שיהיה לי שני תפקידים ששניהם נקראים אדמיניסטרטור. ומיד לאחר מכן אני מוסיף שלושה רולים חדשים, אדמין, מנאג'ר ויוזר.
אז כעת יש לנו טבלת roles עם שלושה תפקידים. לאחר מכן יש לנו טבלת users, כאן אנחנו רואים מפתח ראשי user ID שהוא גם כן מיסטור אוטומטי רץ, מתחיל באחד ומתקדם לתקופות של אחד, user name כמובן חייב להיות יוניקי, כי אנחנו נקבע את ההגדרה של יוניק, password not null, גם אם הuser name not null, וכמובן אתם יכולים
להוסיף כל דבר אחר שברצונכם להוסיף עבור יוזרים. שם פרטי, שם משפחה, תעודת זהות, כתובת, מה שיש לכם עבור יוזרים. אני כרגע השתמשתי במינימום שדרוש בשביל להגדיר יוזר פשוט. הטבלה הבאה שלנו היא טבלה מאוד מעניינת.
היא מגדירה איזה רולים שייכים לאיזה יוזר. רול כמובן זה תפקיד. עכשיו, למה יש טבלה נפרדת? הסיבה היא בגלל שיכול להיות שיוזר מסוים אנחנו רוצים להגדיר לו יותר מרול אחד יכול להיות שיש יוזר שהוא אדמיניסטרטור ואנחנו רוצים שהוא גם יהיה מנהל בכדי שאותו יוזר יוכל לבצע גם את הפעולות של מנהל זה לא אומר שאדמיניסטרטור יכול לבצע את כל הפעולות שכל היוזרים יכולים לעשות
יכול להיות שאדמיניסטרטור יכול לבצע פעולות מסוימות לדוגמה ומזכירה יכולה לבצע פעולות אחרות אנחנו רוצים שיוזר אחד יהיה גם אדמיניסטרטור וגם אדמיניסטרטור לדרך כלל אנחנו ניתן למי שהזמין את האתר איזשהו יוזר התחלתי שמכיל את כל התפקידים לפני שהוא יוכל להיות כולם ביחד
ולעשות את כל מה שכולם יכולים לעשות. זה בדרך כלל מה שעושים, נותנים לי יובר אחד בדאטאבייס שהוא בעצם מכיל את כל התפקידים. אז בואו נסתכל מה יש בטבלה הזאת. בטבלה הזאת יש לנו איזה user ID אנחנו רוצים להתייחס אליו, אנחנו רואים שזה קישור לטבלת היוזרים לעמודת user ID, איזה role אנחנו רוצים לתת עבור היוזר הזה, וזה עמודה שהיא מקושרת לטבלת הרולס לעמודת
רול איידי ואנחנו רוצים להגדיר את שני החבר'ה האלה בתור מפתח ראשי. למה?
בגלל שלא הגיוני שאנחנו נגדיר פעמיים, נניח user 8 role 1, נגדיר אותו עוד פעם user 8 role 1. מספיק שפעם אחת הגדרנו את זה, אז נהוג שבטבלה כזאת, שטבלה כזאת נקראת טבלת מרמול או באנגלית normalization table, שתי העמודות האלה שהן בסך הכל קישורים וטבועות אחרות שתיהן מוגדרות בתור מפתח ראשי וזה בדיוק מתבצע
בפקודה הזאת פריימרי קי, יוזר איידי ורול איידי לאחר מכן אספתי יוזר אחד קראתי לו אסף סיסמה 1234 לטבלת היוזרים והגדרתי שאותו יוזר יש לו שימו לב שהיוזר הזה האיידי שלו הוא 1 יש לו גם את רול מספר 1 גם את רול מספר 2 וגם את רול מספר 3 זה אומר שהיוזר הזה הוא בעצם הכל מנג'ר ויוזר.
בואו נסתכל על טבלת היוזרים, יש לנו פה את טבלת היוזרים, נסתכל עליה ונראה שיש לנו פה יוזר אחד, נקרא אסף, פאסורד 123. בואו נסתכל על טבלת הרולס, בטבלת הרולס אנחנו יכולים לראות שיש לו שעה רולים אדמין, מנג'ר ויוזר עם רול ID 123 וביוזר vs רולס אנחנו יכולים לראות שיוזר מספר אחת הוא גם אדמין,
יוזר מספר אחת הוא גם יונג'ר ויוזר מספר אחת הוא גם יוזר פשוט אז בעצם יש לנו פה את הדאטאבייס שאפשר לנו להכיל את שלושת הטבלאות בעצם שאנחנו הולכים לנהל אז אם אנחנו עכשיו חוזרים בחזרה אנחנו יכולים לראות שברולס לוג'יק כלומר הלוגיקה שתשורה לפקידים יש לנו כל מיני פונקציות שמאפשרות לנו לנהל את זה יש לנו add user
to role שמאפשר לאתר אינטרנט להוסיף יוזר לרול מסוים זו פונקציה שאומרת add users to roles, כלומר היא מקבלת מספר יוזרים, מספר רולים, והיא מכניסה את כל היוזרים האלה לכל הרולים האלה.
אלה פונקציות מאוד נפוצות שאנחנו תכף נראה איפה אנחנו מיישמים אותן. create role מקבלת role name ויוצרת רול חדש, גם כן יכול להיות שבהמשך מנהל האתר ירצה ליצור עוד איזשהו תפקיד, אנחנו יכולים לאפשר לו את זה.
update role מאפשרת לעדכן role קיים, delete role מאפשרת למחוק role קיים, יש לנו כאן פונקציה שאומרת find users in roles, תביא לי את כל היוזרים שנמצאים ברול מסוים, יש לנו פה get all roles, פשוט תביא לי את כל הרולים, get roles for user, תביא לי את כל הרולים ששייכים ליוזר ספציפי, get users in role,
תביא לי את כל היוזרים ששייכים לרול מסוים, כאשר ההבדל בין הפונקציה הזאת לפונקציה הקודמת שראינו, users in role ושהפונקציה find users in role מקבלת username to match, כלומר חלק מהיוזרניים שאנחנו מחפשים, אנחנו מחפשים פה ב-contain ו-get users in role, פשוט אנחנו מקבלים את כל היוזרים שנמצאים
לדוגמה באדמיסטאגר. יש לנו פה את הפונקציה if user in role שבודקת האם יוזר נמצא ברול מסוים, remove users from role, הסיר לי בבקשה את היוזרים מרול מסוים, remove users from roles תסיר לי את כל היוזרים האלה מכל הרולים האלה ופונקציה שבודקת האם
role קיים כן או לא. זאת אומרת יש לנו כאן business logic מפורט לגמרי שמאפשר לנו לנהל את כל הסיפור הזה בנוסף לכל ניהול המוצרים גם ניהול היוזרים וניהול הרולים.
ואנחנו עכשיו יכולים לעבור לאתר ולראות מה אנחנו בעצם קודם כל צריכים להוסיף בשביל שהאתר שלנו יתמוך ברולים. הדבר הראשון שאנחנו צריכים לעשות בכדי שהמנגנון ה-Security שלנו יתמוך ב-Roles זה להוסיף מחלקה, בואו נוסיף אותה ל-Controllers, שיורשת מהמחלקה
האבסטרקטית roleProvider ונותנת שירותים לגבי roles. בואו נקרא למחלקה הזאת n-wing, כלומר North-wing roleProvider. עכשיו בואו נירש מהמחלקה האבסטרקטית roleProvider, שנמצאת בתוך SystemWebSecurity אנחנו יכולים להוציא את ה-Namespace.controllers ש.NET מוסיפה לכל קונטרולר כי זה ה-Namespace שלנו
Users and Brokers of Authorization והמחלקה roleProviders זאת מחלקה אבסטרקטית שיש לה מגוון פונקציות אבסטרקטיות ואנחנו יכולים פשוט לממש אותה. נלחץ על Implement Abstract Class roleProviders ונקבל פה המון המון פונקציות שמטפלות בכל הנושא של תפקידים ואנחנו צריכים ללכת ולממש כל אחת מהפונקציות האלה
פשוט על ידי קריאה ל-Business Logic שלנו ושמירת הנתונים בתוך ה-Datables. אז בואו נעבור פונקציה פונקציה ונראה מה אנחנו צריכים לעשות.
בפונקציה הראשונה שלנו Add Users to Roles כל מה שאנחנו רוצים לעשות זה לקרוא ל-Business Logic ולכן בואו ניצור כאן מחלקה או יותר נכון Object Private Roles Logic וכעת אנחנו יכולים להשתמש באובייקט roles logic בכדי לשמור את כל השינויים בדאטאבלס.
אז יש לנו פה add users to roles, ניתן לו את ה-user names ואת ה-role names. הדבר הבא שלנו זה application name, זה רק אמור להחזיר את השם של האפליקציה, אז בואו נפתח כאן private string application name, ונחשוב מה השם של האפליקציה שלנו, השם יכול להיות northwind website, ופשוט נחזיר אותו במידה ובעתיד נרצה להשתמש, אנחנו לא חייבים אבל אולי נרצה לקבל את השם
של האפליקציה. אז כאן אנחנו פשוט מחזירים את ApplicationName וכאן אנחנו מגדירים ApplicationName שווה Value אם נרצה לשנות אותה בהמשך.
בואו נראה את הפונקציה הבאה, פונקציית CreateRoll, יש לנו פה את RollProvider, CreateRoll, הדבר הבא שאנחנו עושים, DeleteRoll, נעביר לו RollName ויש לנו פה משתנה שאומר האם אם אנחנו רוצים שהמערכת תזרוק חריגה במידה ואנחנו לא יכולים למחוק את התפקיד הזה כי
יש לו יוזרים או שאנחנו רוצים להתעלם מזה ופשוט לא אצליח למחוק והחזירנו לדבר פולט. כאן יש לנו find users in roles, role name, user name, match, יש לנו פונקציה בתפקיד שלה זה להחזיר את כל ה-roles, כאן יש לנו get roles for user,
is user in role, remove users from roles והפונקציה האחרונה האם role קיים כנראה, אוקיי אז בעצם הדבר הראשון שעשינו בשביל לשלב בתוך המערכת את קונספט של roles בסקיריטי זה לבנות מחלקה מאוד מיוחדת שנקראת nwind role provider, היא יכולה להיקרא בכל שם אחר והיא חייבת לרשת את role provider.
אנחנו עוברים לנקודה השנייה שאנחנו צריכים לעשות, וזה להגדיר לאתר שאנחנו בונים כרגע, שיכיר את המחלקה הזאת בתור המחלקה שאליה הוא צריך לפנות בשביל לדעת איזה רולים קיימים, האם יוזר שייך לרול מסוים, האם קיים לי רול כזה, כן או לא, ועוד כל מיני פגיעות אחרות. כלומר, אנחנו רוצים ש-MVC אכן תפעיל את הפונקציה
במחלקה הזאת, בכדי לפנות לדאטאבייס ולקבל נתונים לגבי הרול. את ההגדרות האלה, כלומר את הכירות הזאת במחלקה מבחינת ה-MVC, אנחנו עושים בתוך ה-Web Config של האתר.
אז בואו ניגש ל-WebConfig, זה בעצם הקובץ הזה, ונראה מה אנחנו צריכים להוסיף בדיוק בקובץ הזה, בכדי שהאתר שלנו יכיר את המחלקה שכרגע בנינו.
אז בתוך הקובץ הזה, מה שאנחנו צריכים לעשות זה קודם כל לגשת ל-App Settings ולהוסיף שתי מפתחות המפתח הראשון נקרא נייבל סינקל מונדושי והוואליו שלו הוא שווה טריקו שווה ליותר דיוק פולס המפתח השני שאנחנו צריכים להוסיף זה מפתח בעל קי אוטו פורמס אוטרינפיקיישן גם כאן הוואליו שלו
הוא פולס מה זה שני המפתחות האלה? מפתחות האלה מונעים בעצם מהאתר שלנו של mvc להתייחס למסד נתונים דיפולטי שקיים מבחינת mvc כלומר mvc יכולה לעבוד עם איזשהו מסד נתונים שנקרא asp.net.db ולכן לפנות למסד נתונים הזה בכדי לבדוק האם שמה מוגדרים הרולס והיוזר ואנחנו בעצם רוצים לעבוד עם מסד נתונים משלנו
אז אנחנו מבטלים את האופציה הזאת ש-MVC תעבוד עם מסד נתונים אחר מהמסד נתונים שלנו. לאחר מכן אנחנו פונים לתגית System.Web שנמצאת בתוך תגית Configuration.
בואו נסמן קודם כל שזה משהו שאנחנו הוספנו ונוסיף גם כאן תגית נוספת. תגית שאנחנו צריכים להוסיף בתוך התגית System.Web זו תגית שנקראת role Manager. בואו נבצע פתיחה וסגירה.
ברול מנאג'ר יש לנו enabled שווה אנחנו מאפשרים עבודה עם roles ואנחנו צריכים להגדיר default provider אז בואו נגדיר שהdefault provider שלנו זה סתם איזשהו שם שאנחנו יכולים לענות והdefault provider שלנו צריך להינתן בדיוק כאן בואו נפתח פה provider ונגדיר בדיוק את הטייפ של הprovider שבנינו בואו נחזור למחלקה שבנינו ונראה שהמחלקה שבנינו
נקראת n-wind role provider והיא נמצאת קודם כל בתוך מרחב שמות שנקרא users and roles authorization בואו ניקח את המרחב שמות הזה נשים אותו כאן נחזור בחזרה נעתיק את המחלקה נרשום פה נקודה ואת המחלקה זאת אומרת שהמחלקה שמספקת את הנתונים לגבי ה-roles עבור אתר ה-MVC שלנו נקראת n-wind ורול פרוביידר ומוצאת בתוך מרחב השמות Users
and Authorization כך MVC יכולה לבנות אובייקט ממנה. לאחר מכן אנחנו ממציאים איזשהו שם, זה יכול להיות כל שם, אבל מה שנהוג לעשות זה פשוט לקחת את אותו השם של המחלקה ולכתוב כאן.
ואז אנחנו מגדירים שהדיפולט פרוביידר שעל MVC להשתמש זה בדיוק השם שנתנו כאן. ובעצם כל ההגדרה הזאת זאת הגדרה שמגדירה עבור מבצעים איזה פרוביידר של תפקידים על האתר שלנו להשתמש בו, וזה בדיוק הפרוביידר שאנחנו בנינו.
כעת אנחנו יכולים ללכת ולהגביר למי מותר ולמי אסור להיכנס לכל האקשנים השונים שיש לנו. אז אנחנו חוזרים לקונטרולר ואנחנו רואים שיש לנו פה פרודקטס קונטרולר, ובפרודקטס קונטרולר בנינו את כל האקשנס שאחראים על טיפול המוצרים.
אנחנו רואים שיש לנו פה אינדקס שמציגה את כל המוצרים. אנחנו רואים שיש לנו פה קריאט וקריאט, אחת לגט, אחת לפוסט, שיוצרת מוצר חדש. אדיט שעורכת מוצר קיים ודיליט שמוחקת מוצר.
אנחנו רוצים לתת פה הרשאות, אבל הפעם אנחנו רוצים לתת הרשאות שקשורות לתפקידים. אז בואו נחליט את ההחלטות הבאות. מי שמסוגל להיכנס לאינדקס ולראות את כל הרשימה של המוצרים זה רק משתמשים רשומים במערכת.
כלומר, אם משתמש ביצע לוג-אין, מבחינתי הוא מסוגל לראות את המוצרים. הוא לא יהיה מסוגל לבצע הוספה, עדכון או מחיקה, אבל לראות את המוצרים הוא יהיה מסוגל לראות אותם.
אם המשתמש לא נרשם במערכת על ידי יוזמה ופרסוורד, ולא עשה לוג-אין, הוא אפילו לא יוכל לראות את רשימת המוצרים. לצורך כך אנחנו צריכים להגדיר מעל לאינדקסט את האטריביוט autorize.
וזה אומר, אתה חייב להיות יוזר שביצע לוג-אין בכדי שתוכל לגלוש לתוך האקשן הזה. ב-Create אנחנו רוצים לתת אישור לביצוע הוספה של מוצר רק למנהלים ורק אם אתה מנאג'ר אנחנו רוצים לאפשר לך להוסיף מוצר חדש ולכן אנחנו מוסיפים את ה-Attribute Authorized ואנחנו מגדירים roles שווה מנאג'ר כאן ברגע
שהיוזר ינסה להיכנס ל-Create mvc תשתמש ברול פרוביידר שבנינו ממש לפני כמה דקות בכדי לגשת לדאטאבייס להביא את הרול של היוזר הנוכחי ולראות האם הרול שלו נמצא כמנאג'ר האם הרול שלו אחד מהרולים שלו זה מנאג'ר אם כן יש לו אפשרות להיכנס לקריאי אם לא כמובן שmvc לא תיתן לו אפשרות להיכנס ותנתב אותו
לדף לוגין את הדבר הזה לזה אנחנו רוצים לשכפל גם לפונקציית הפוסט כי זה לא משנה לי אם היוזר גלש בגט או גלש בפוסט הוא לא יהיה מסוגל להוסיף מוצר אם הוא לא מנג'ר.
את אותו הסיפור של מנג'ר אנחנו רוצים לבצע גם באדיק אז בואו נדביק את זה פה ונדביק את זה פה ועבור delete בואו נחליט שרק אם אתה אדמיניסטרטור אתה מסוגל לבצע מחיקה של מוצר אז בואו נדביק מעל delete את authorized ונגדיר roles admin מבצע העתקה, הדבקה וכרגע יש לנו עבור delete את הקונספט של אדמיניסטרטור.
בואו נבדוק את האתר. אז מקודם אנחנו ראינו כאשר הרצנו את האתר הזה שגם אם לא ביצעתי שום לוגין יכלתי להיכנס ולראות את כל המוצרים, יכלתי להוסיף, לעדכן ולמחוק מוצר.
כעת אני נכנס לדף הבית, אני כרגע גסט, אני לא רשום במערכת, אני יכול לראות כאן שאני גסט וכל מה שאני מנסה לעשות זה לצפות במוצרים.
VC אוטומטית מעיפה אותי לדף לוגין ואומרת לי חבוב אתה בעצם לא יכול לראות את המוצרים עד שאתה לא מבצע לוגין שימו לב שהיא הפנתה אותי לדף אקאונט לוגין ושולחת פה ריטרן url בעצם את הדף פרודקטס אינדקס בכדי שאם אני אכניס את הפרטים היא תוכל להפנות אותי בחזרה לדף שממנו הגעתי שזה בעצם המוצרים עצמם
אז בואו נכניס את היוזר אסף, סיסמה 1234, נבצע לוגין ואנחנו רואים שאנחנו מופנים מיידית לדף המוצרים.
עכשיו אני רואה שיש לי פה הלו אסף ואני יכול לעשות פלוג אאוט, אבל בואו נראה אם אני יכול עכשיו לבצע פעולות נוספות.
לדוגמה, האם אני יכול להוסיף מוצר? בואו נלך על קריאייט מפרודקט, נוסיף פלאפל שעולה 12.5, נבצע קריאייט ואנחנו רואים ש-MVC אפשרה לנו לייצר מוצר חדש.
בואו נלך לאדיט נעדכן שהמוצר הזה עולה נניח 15 נבצע update mvc אישרה לנו לעשות את זה נבצע delete על המוצר אנחנו כבר רואים שהגענו לדף זאת אומרת שגם כאן mvc מאשרת לנו והסיבה ש-mvc אישרה לנו לעשות את זה זה בגלל שהיוזר אסף מוגדר במערכת יכולים לראות את זה כאן כגם אדמיניסטרטור זאת ההגדרה גם מנאג'ר וגם יוזר פשוט
אנחנו ביצענו את זה בטבלה הזאת, אנחנו רואים פה את ההוספה של כל היוזרים. אז בעצם יש לנו כרגע את ההגנות לפי רולז והדבר הבא שאנחנו הולכים לראות זה איך בעצם אנחנו יכולים לאפשר לאדמיניסטרטור או לבן אדם אחר לבצע עריכה של רולז דרך האתר.
בואו נבצע פה סגירה, נחזור בחזרה ונראה מה הדבר הבא שאנחנו צריכים לעשות. הדבר הבא שאנחנו צריכים לאפשר זה בעצם עריכה או יותר נכון ניהול של כל הנושא של הרולס באתר שלנו.
לצורך כך עלינו ליצור קונטרולר שאחראי על ניהול הרולס. אז בואו נוסיף קונטרולר ונקרא לקונטרולר הזה roles.controller נגדיר אותו כ-MP ובואו נתחיל לבנות את הפונקציות הדרושות לניהול הרולים השונים.
דבר ראשון יש לנו פה את אינדקס שהתפקיד שלה זה ופשוט להציג למשתמש מה האפשרויות של ניהול התפקידים השונים באתר. הוספת תפקיד, עריכת תפקיד, מחיקת תפקיד, הוספת תפקיד ליוזר קיים וכו'.
אז זה בעצם יהיה האינדקס שלנו. לאחר מכן יש לנו פונקציה קריאייט. בואו נבנה public actionResult:create. נחזיר פה ל-vue ונבצע עוד קריאייט עבור http-host שמקבלת את הרול שאנחנו רוצים להוסיף, זה יהיה המודל שלנו, כמו תמיד יש לנו פה בדיקת ולידציה אם not model state is valid נחזיר את אותו ה-view לאחר מכן
נבנה אובייקט מהלוג'יק ונשתמש בביזנס לוג'יק שבנינו בשביל להוסיף את הרולנינג כרול חדש לאחר מכן נחזיר redirect to action index אז יש לנו פה את ה-create כעת אנחנו יכולים גם ליצור רול קיים ליצור רול חדש לאחר מכן בואו נבצע delete עבור מפיקה פרול קיים יש לנו פה public action
resort delete פונקציה הזאת היא עבור גט נבנה עוד אחת עבור htp cost מה אנחנו רוצים לעשות בדיליט של גט מה שאנחנו רוצים לעשות בדיליט של גט זה בעצם לגשת בעזרת ה-roll logic ולהחזיר כל הרולים כל התפקידים בכדי שהבן אדם יוכל לבחור איזה תפקיד הוא רוצה למחוק מהמערכת ככה הוא יוכל לראות את כולם
ולמחוק את התפקיד שהוא לא מעוניין בו יותר. אז יש לנו פה את הפונקציה get all roles שמחזירה שימו לב מערך של סטרינגים ככה ה-view יוכל להציג מערך של סטרינגים ולאפשר למשתמש למחוק role מסוים.
כאן אנחנו רוצים לקבל את המודל בעצם שוב פעם לבצע בדיקת תקינות ולידציה זאת הבדיקה הזאת היא זהה תמיד במידה והבן אדם רוצה למחוק role אנחנו צריכים לאפשר למחוק ב-database אבל ספציפית מחיקה יכולה לעלות חריגה.
בואו נבצע פה טרייקאץ', בטריי מה שנעשה, ננסה לבצע מחיקה ונגדיר true, כלומר throw on populated role, במידה והרול הזה מכיל יוזרים ששייכים לרול הזה, כמובן המשתמש לא יכול למחוק אותו.
אנחנו כן רוצים לאפשר זריקת חריגה, כי אנחנו רוצים לתפוס את החריגה ולהודיע איזושהי הודעה. אם הכל הצליח, בסוף ה-try אנחנו מבצעים redirect to action מה אנחנו עושים בקאץ׳ בקאץ׳ כל מה שאנחנו צריכים לעשות זה להודיע הודעה עבור ה-view עצמו אבל אנחנו רוצים להחזיר בחזרה את ה-view הקודם כי אם
אנחנו נחזיר את ה-view הזה לא יהיה למשתמש את הרשימה של הרולים שהוא רואה בכדי להמשיך ולבחור אחד אחר לדוגמה מה שאנחנו רוצים לעשות בקאץ׳ פשוט מאוד לבצע return delete זה בעצם ה delete הראשונה אבל אנחנו רוצים להציג הודעה לצורך כך ניקח temp data error message can't delete this all because there are users on this all למה
אנחנו משתמשים בtemp data כי אם אנחנו בעצם רוצים לחזור בחזרה ולהציג ללקוח view אחר אנחנו רוצים שהמידע הזה של ה-errorMessage ימשיך להישמר גם ב-request נוסף שחוזר ללקוח.
את זה אנחנו לא צריכים, ופה בעצם סיימנו את הקונספט של ה-delay. הדבר הבא שאנחנו רוצים לאפשר למשתמש זה בעצם לחבר יוזר ל-Role מסוים. בואו נבנה פה פונקציה שאומרת Add User to Role.
הרי אם יוזר חדש יתחבר לנו לאתר, לא הגיוני שהיוזר עצמו יקבע מה התפקיד שלו, כי אחרת כל יוזר היה יכול לקבוע שהתפקיד שלו זה אדמיניסטרטור לדוגמה. אז מה שקורה בדרך כלל זה כאשר יוזר מתחבר למערכת קודם כל בי דיפולט הוא מוגדר ברול פשוט ביותר כמו יוזר כמו שיש לנו יש לנו איזה שהוא רול שהוא יוזר אנחנו יכולים להגדיר יש דיפולט ברגע שיוזר מתחבר
הוא יוזר אנחנו יכולים להגדיר שבכלל אין לו רול ברגע שהוא מתחבר הוא רק רג'יסטר כלומר רק מתחבר למערכת ואם יש לנו אטריביוט שנקרא authorized אנחנו יכולים להתייחס רק ליוזרים שעושים לוגים אבל אנחנו צריכים שאיזשהו מנהל או אדמיניסטרטור יוכל לקחת יוזר ספציפי ולהגדיר אותו תחת רול מסוים לדוגמה
מנאג'ר לדוגמה להגדיר איזשהו יוזר כמנאג'ר ולכן זאת הפונקציה הזאת add user to role שמאפשרת למישהו לדוגמה לאדמיניסטרטור להגדיר יוזר ספציפי לפי איזה רול שהוא רוצה אז מה בעצם אנחנו צריכים לבצע בפונקציה הזאת. בפונקציה הזאת אנחנו צריכים לאפשר להציג ויו שמראה את כל היוברים ואת כל הרולים וככה המשתמש יכול לבחור יוזר, להתאים לו רול, ללחוץ על לחצן סמית
ואז המערכת צריכה להוסיף את היוזר הזה כאחד כזה שזה התפקיד שלו. כלומר היוזר שנבחר עם התפקיד שנבחר. לצורך כך אנחנו צריכים ללכת ולבנות ויו מודל ספציפי בשביל הפעילות הזאת.
מה זה אומר? הרי אנחנו רוצים שה-view יציג רשימה של יוזרים ורשימה של roles בכדי שאותו אדמיניסטרטור יוכל לבחור user ולהתאים לו role.
אז לצורך כך אנחנו צריכים לבנות מודל ייעודי עבור הדבר הזה. לכן אנחנו צריכים כעת ללכת למודלס, בואו ניגש למודלים, נראה שהמודלים שיש לנו פה זה רק לוגין ורוויסטר, ולהוסיף עוד מודל אחד, בואו נוסיף לו קלאס, ונגדיר שהקלאס נקראת Add User to role U-Model.
אז בואו נבנה כאן מאפיין אחד שהוא מערך מחוזות, נקרא לו roleRolesNames ליתר דיוק בואו נקרא לו roleNames ועוד אחד ונקרא לו UserNames ויש לנו את המודל המיוחד שאנחנו צריכים בשביל להציג את רשימת ה-Rולים ואת רשימת ה-User.
אנחנו יכולים לבדור אותו, לחזור בחזרה ולראות איך אנחנו יכולים לבנות את הפונקציה AddUserToRול. דבר שאנחנו צריכים לעשות זה לגשת על ידי Using ל-RolesLogic, על ידי עוד Using ל-UsersLogic, לקחת פה סטרינג של RollNames, לקחת פה עוד מערך סטרינג של UserNames לבנות אובייקט מהטיפוס AddUserToRollViewModel זה המודל שלנו ה-RollNames יהיה המשתנה
RollNames שהגדרנו ה-UserNames יהיה המשתנה UserNames שהגדרנו אנחנו מסוגלים עכשיו להחזיר View ולתת לו את המודל סיימנו לבנות את הפונקציה הזאת ואנחנו יכולים לבנות את החלק של ה-HTTP פוסט שלה.
כאן, כאשר המשתמש יבצע סאבמיט, הוא יגלוש בחזרה לפונקציה הזאת, שולח לנו user name, שולח לנו role name, כל מה שאנחנו צריכים לעשות זה לנסות להוסיף אותו לדאטאבייס.
אז יש לנו פה פרייל, יש לנו פונקציה add user to role, ניתן לה את ה-user name, את ה-role name, והיא תוסיף אותו ל-role המבוקש.
ואנחנו מחזירים בחזרה לאינדקס. במידה והייתה לנו חריגה אנחנו יכולים להודיע איזושהי הודעת שגיאה user לדוגמה already contained in role מפני שהמשתמש מנסה להוסיף user ל-role כאשר ה-user הזה כבר מוגדר ב-role וזאת היא שגיאה נפוצה שיכולה להיות.
נחזיר add user to role, הפונקציה הראשונה, בכדי ששוב פעם יתמלאו כל הערכים והמשתמש יוכל לראות בעצם עוד פעם את כל היוזרים ואת כל הרולים ולבחור אחד אחר.
פה בעצם סיימנו לבנות את הקונטרולר של ה-Roles ואנחנו מוכנים ללכת ולבנות את ה-Views השונים. אז שנייה לפני שנלך ונבנה את ה-Views בואו נחשוב מי אנחנו רוצים שיוכל לראות את כל ה-Views האלה ואנחנו רוצים לאפשר רק לדוגמה לאדמיניסטרטור את היכולת לנהל רולים
ולכן אנחנו יכולים להגדיר מעל ה-Roles קונטרולר את המאפיין authorized roles=admin כך אנחנו יכולים להיות בטוחים שרק אם אתה אדמיניסטרטור אתה יכול בכלל להיכנס לכל אחת מהפונקציות האלה ובואו נתחיל לבנות אותן אז יש לנו את האינדקס נוסיף view ובואו נבנה את הview הזה כך שהוא יוכל לאפשר תצוגה של כל הפעולות שניתן לבצע על roles נגדיר פה manage roles גם בכותרת נגדיר כאן לינקים לינק
ראשון create new role ואנחנו שולחים לפונקציית create לינק שני נבצע delete אנחנו שולחים לפונקציה delete לינק שלישי add user to role ואנחנו שולחים לפונקציה add user to role אוקיי אז בעצם האינדקס כרגע מוכן ואנחנו מסוגלים ללכת ולבנות את הפונקציה
הראשונה שזה בעצם הקריאייט בואו נחזור לקונטרולר ניגש לקריאייט ונבנה עבורה view המודל שלנו הוא כמובן role אנחנו נמצאים בקריאייט role מה שאנחנו רוצים לעשות זה ליצור פורם ואנחנו אנחנו רוצים לתת למשתמש אפשרות לבנות role חדש, להוסיף role חדש.
יש לנו פה Label 4 במודל שלנו, אנחנו רוצים לאפשר להכניס role name. יש לנו פה את הנקודותיים, לאחר מכן יש לנו Editor 4, לאחר מכן יש לנו את הוולידציה, Validation Message 4.