ארכיון הקטגוריה: yii2

התקנת yii2 על linux ללא composer

מורידים את הקובץ tar מכאן http://www.yiiframework.com/download/

לאחר מכן,
מעתיקים אותו לתיקית ה-web שלכם.

נותנים לו הרשאות מלאות (אפשר פשוט לתת בעלות ליוזר של apache, באמצעות chown )

ואז גולשים בדפדפן אל התיקיה ו-גמרנו.

http://localhost/basic/web/index.php

הערה : אומנם לפי התיעוד הרשמי, אמורים להיכנס לתיקית config, ולערוך את קובץ web.php – ולרשום בו סיסמא כלשהיא להצפנת ה-cookies , בערך cookieValidationKey, אבל אם אתם מורידים את פרויקט ה-basic/advanced , ולא פריימוורק ריק, אז זה קיים כבר.

אם מסיבה כלשהיא זה לא עובד , ניתן לבצע בדיקה של דרישות ברירת המחדל באמצעות גלישה אל http://localhost/basic/requirements.php

או הפעלה של קובץ זה משורת הפקודה.

הגדרות מומלצות עבור ה-Apache בשביל yii2 בסביבת production

בשרת production, היינו רוצים לגלוש לאפליקציה/אתר שלנו ישירות כך : http://www.example.com/index.php

ולא כך : http://www.example.com/basic/web/index.php

לשם כך נדרש להפנות את ה-Virtual host ישירות אל תיקית  basic/web.

בנוסף נרצה בוודאי להסתיר את index.php משורת הכתובת.

כדי לבצע את הדברים האלו, יש להגדיר בקובץ httpd.conf , או בתוך הקובץ שמגדיר את ה-virtual host, את ההגדרות הבאות :

# Set document root to be "basic/web"
DocumentRoot "path/to/basic/web"

<Directory "path/to/basic/web">
    # use mod_rewrite for pretty URL support
    RewriteEngine on
    # If a directory or a file exists, use the request directly
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    # Otherwise forward the request to index.php
    RewriteRule . index.php

    # ...other settings...
</Directory>

יש לזה יתרונות נוספים, ברגע שמגדירים את bsic/web כתיקית ברירת המחדל של ה-virtual host, מונעים למעשה מהגולשים אפשרות לגשת לתיקיות פנימיות רגישות, שהם אינם צריכים לראות.

זכויות יוצרים : המדריך פורסם לפי התנאים של Yii , והמקור נמצא בקישור הבא :  http://www.yiiframework.com/doc-2.0/guide-start-installation.html

מדריך Yii 2 – הרצת אפליקציות (הבסיס)

אחרי שמתקינים את Yii 2 ,ניתן לגשת לאפליקציה באמצעות ה-URL : http://hostname/basic/web/index.php או http://hostname/index.php תלוי בהגדרות של שרת ה-Web.  במדריך הזה נלמד איך מאורגן הקוד, ואיך מנותבת כל בקשה (request) של הגולש .

הנחת יסוד : יש לכם את תיקית basic/web בתיקיה שמחזיק שרת ה-web ( נניח localhost/basic/web) . כמובן, אם התקנתם את זה בתיקיה אחרת , תתאימו את הכתובות של ה-URL בהתאם.

אפליקצית ה-Basic, מכילה 4 עמודים :

  • דף הבית שניתן להגיע אליו דרך ה-URL – http://hostname/index.php
  • דף ה-About
  • דף ה-Contact שמכיל טופס  יצירת קשר דרך מייל
  • דף login  – שמכיל את היכולת לבדוק משתמש, אם תנסו אותו,עם admin/admin תוכלו לראות שהמילה login הופכת להיות logout.

העמודים האלו חולקים יחד את אותו Header , Footer, Menu .

בתחתית אפשר לראות כלי חזק מאוד של Yii שנקרא  debugger tool שמספק עזרה מאוד נחוצה כמו הודעות Log , שאילתות ל-DB, סטטוטים של בקשות ועוד.

מבנה האפליקציה ב-Yii

  • תיקית basic  – מכילה את כל האפליקציה
    • composer.json – לשימוש באמצעות ה-Composer
    • תיקית Config – הגדרות
      • console.php הגדרות של ה-console
      • web.php – הגדרות של האפליקציה
    • תיקית commands – מכילה פקודות של ה-console
    • תיקית controllers – מכילה את קבצי הקונטרולרים
    • תיקית models – מכילה את קבצי המודלים
    • תיקית runtime – מכילה קבצי ש-Yii מייצרת תוך כדי ריצה, כמו לוגים, ו-cache.
    • תיקית vendor – מכילה חבילות שהותקנו על ידי ה-composer, כולל את קבצי הליבה של Yii.
    • תיקית views – מכילה את קבצי ה-view
    • תיקית web
      • index.php – קובץ הגישה לאפליקציה
      • assets – קבצי css + JS
    • קובץ yii (או קובץ yii.bat) – קובץ ה-console.

מה צריך להיות חשוף למשתמש ?

ב-Yii אפשר לחלק את הקבצים כך : כל מה שנמצא בתיקית web, נגיש לגולש, כל השאר – צריך להיות לא נגיש לגולש, ונגיש רק לשרת/לסקריפטים.

Yii משתמשת כמו פריימורקים רבים בשיטת/מתודולגית MVC, כפי שבוודאי שמת לב מהמבנה של התיקיות -models/views/controllers – מכילות כל אחת את הקבצים הרלוונטים.

איך מנותבת בקשה/request ב-Yii ?

לכל אפליקציה יש קובץ index.php שהוא הקובץ היחיד שנגיש לגולש. קובץ זה לוקח את ה-request ויוצר מופע של המחלקה application ואז מתחיל לטפל ב-request.

המחלקה application מפענחת את ה-request עם סיוע של רכיבי ה-components ומנתבת את ה-request בין רכיבי ה-MVC.

יש לציין שבחלק של ה-views, נעזרים ב-Widgets כדי לבנות את ה-views.

 ניתוב של request ב-Yii – שלב אחרי שלב

  1. הגולש מקליד כתובת, ונשלח request ל-enrty script, שהוא כאמור , קובץ web/index.php
  2. הגדרות ה-configuration נטענות . ובנוסף נוצר מופע (instance) של המחלקה application כדי לטפל ב-request.
  3. המחלקה application מפענחת את הנתיב – route, עם עזרה של מרכיב שנקרא -request.
  4. נוצר מופע (instance) של controller כדי לטפל ב-request.
  5. הקונטרולר יוצא מופע (instance) של ה-action הדרוש ומפעיל Filters אם יש צורך.
  6. אם אחד ה-Filters כושל, הפעולה כולה נעצרת (כלומר ה-action כושל).
  7. אם כל ה-Filters עוברים בהצלחה, אז ה-Action מבוצעת.
  8. כאן ה-Action תופס פיקוד, ומבצע  טעינה של המודל (model) ואם זהו מודל שקשור ל-DB, אז נשלפות הרשומות מה-DB.
  9. ה-Action מייצר View ומחזיר את ה-view ביחד עם נתוני ה-model אל השלב הבא. (הייצור של ה-View מכונה render) .
  10. התוצאה מוחזרת אל רכיב ה-response.
  11. רכיב ה-reposnse שולח תשובה אל הדפדפן של הגולש.

זכויות יוצרים : המדריך פורסם לפי התנאים של Yii , והמקור נמצא בקישור הזה.

מדריך Yii 2 – אפליקצית "שלום עולם"

המדריך הזה מתאר איך ליצור אפליקצית "שלום עולם"  על מנת לבצע זאת, אנו ניצור action וגם view :

  • האפליקציה תשלח בקשה (request)  לדף אל ה-action
  • ואז ה-action תייצר את ה-view ותציג את המילה Hello אל הגולש.

במסגרת מדריך זה תלמד 3 דברים :

  • איך ליצור action – פעולה שמגיבה לבקשה (=request)
  • איך ליצור view שיציג את תוכן המענה לבקשה (=response)
  • איך האפליקציה שולחת בקשות (requests ) אל actions.

איך ליצור Action ב- Yii

כדי ליישם את אפליקצית שלום עולם ב-Yii אנחנו ניצור action שיקרא say. ה-Action הזה, היא פונקציה של מחלקה, שתקבל פרמטר בשם message מה-request  ותציג את ההודעה לגולש.

אם ה-request נשלחה ללא הפרמטר message , אז ה-action תציג את ברירת המחדל – המילה Hello.

מה זה בעצם Action ב- Yii ?

Actions הן אוביקטים שהגולשים יכולים לגלוש אליהם ישירות, אם הם מעוניינים בביצוע פעולה מסויימת . כל ה-Actions מאוגדים יחד תחת Controllers, זאת אומרת ש-Controller אחד מכיל הרבה Actions.

התוצאה של ביצוע Action – היא מה שהגולש מקבל (מכונה גם response).

דוגמא להגדרת Action ב- Yii

כל Action חייבת להיות מוגדרת בתוך Controller. לצורך הפשטות, נגדיר כעת את ה-Action בשם say בתוך Controller שכבר קיים, שנקרא SiteController.

ה-Controller הזה הוא מחלקה שמוגדרת בקובץ controllers/SiteController.php.

כך יש להגדיר את ה-Action בשם say :

<?php

namespace appcontrollers;

use yiiwebController;

class SiteController extends Controller
{
    // ...existing code...

    public function actionSay($message = 'Hello')
    {
        return $this->render('say', ['message' => $message]);
    }
}

הסבר הקוד : ה-Action שנקראת say, הוגדרה כמתודה בשם actionSay בתוך המחלקה SiteCotroller.  כדי להפריד מתודות שהן actions ממתודות אחרות , Yii דורשת שכל action יתחיל במילה action באותיות קטנות. השם שמופיע מייד אחרי המילה action הוא השם המזהה של ה-action, שמכונה גם action ID.

כללים למתן שמות ל-Actions ב- Yii

נפריד בין הצורה שה-action נקרא בתוך המערכת, ובין השם שבו הוא נקרא כאשר מגדירים את המתודה.

שמות של actions בתוך המערכת (=מה שנקרא action's ID )

  1. תמיד באותיות קטנות,.
  2. כאשר אם השם מורכב ממספר מילים, יש להפריד בין המילים באמצעות מקףלמשל create-comment.

המתודה של ה-Action צריכה תמיד להיות

  1. בפורמט CamelCased (=אות ראשונה של כל מילה היא אות גדולה, ללא רווח בין המילים)
  2. עם המילה action באותיות קטנות בתחילת שם המתודה .

למשל : actionCreateComment

במקרה שלנו, ה-Action מקבלת פרמטר במשתנה $message . כאשר הגדרנו ערך ברירת מחדל למשתנה זה – המחרוזת "Hello" (בדיוק בצורה הרגילה שבה מגדירים ערך ברירת מחדל לכל משתנה בפונקציות php).

כאשר האפליקציה תקבל request  ותחליט שהפעולה הנדרשת היא הפעולה say , אז האפליקציה תיקח את הפרמטר שהתקבל ב-request (נניח ב-get בשורת הכתובת) ותעביר אותו את הפונקציה actionSay.

בתוך המתודה actionSay השתמשנו במתודה render() שמה שהיא עושה – היא מחוללת view, על בסיס קובץ view שגם הוא נקרא say.

הפרמטר message מועבר אל ה-view , כדי שנוכל להשתמש בו שם. התוצאה של יצירת ה-view מוחזרת באמצעות ה-Action.

מוחזרת לאן ? – התוצאה מוחזרת לאפליקציה ומוצגת לגולש בדפדפן.

 איך יוצרים View ב- Yii ?

במונח Views מתכוונים לסקריפטים שאתה כותב, כדי לייצר תצוגה של הדף. למשל, במשימה שלנו, אנחנו צריכים לכתוב דף שיציג את הביטוי "שלום עולם" או כל ביטוי אחר שנעביר דרך המשתנה message. לצורך כך אנחנו ניצור view שיקרא בשם say,  שמטרתו להציג את תוכן הפרמטר message. את הפרמטר הוא יקבל מה-action שזה עתה בנינו.

צור קובץ php חדש, ושתול בו את הטקסט הבא :

<?php
use yiihelpersHtml;
?>
<?= Html::encode($message) ?>

הערה חשובה : בדוגמא הזו, נעשה שימוש בקיצור הקוד הבא <?= , והיות והוא לא מוכר לרבים, אז אתן הסבר קצרצר : הקיצור הזה הוא בדיוק כמו לכתוב את הקוד הבא

<?php echo .....bla bla bla

כלומר, במקום לכתוב את תגית הפתיחה המלאה של php, ואת המילה echo, אם משתמשים בקיצור הזה, חוסכים בעצם בכתיבה בכך שרושמים רק 3 תוים.

כדי שזה יעבוד , אז ב-php.ini האפשרות short_open_tag חייבת להיות מאופשרת.

את הקוד ההוא של ה-view שנקרא say עליך לשמור בקובץ /views/site/say.php. ואז, כאשר המתודה render() תופעל בתוך ה-action, היא תחפש קובץ במיקום הבא : views/ControllerID/viewName.php.

שים לב, בקוד פה, עטפנו את הפרמטר message בפקודה HTML-encoded לפני שהדפסנו אותו על המסך.

למה זה טוב ? – זוהי שיטה מקובלת ונחוצה מאוד, כדי למנוע מתקפות XSS באמצעות משלוח של קוד JS זדוני דרך הפרמטר הזה.

בתוך View אתה שם את כל הקוד שמוצג למשתמש, זאת אומרת, תגי Html, טקסט חופשי, וכו' וכו'. מה שקורה בפועל הוא שאחרי שהמתודה render() מופעלת, אז התוכן שמיוצר באמצעות ה-view (שנקראת say בדוגמא שלנו) מוחזר אל האפליקציה ומוצג לגולש, בתור מענה (=response) .

נסה את זה בעצמך !

כעת, הגיע זמן לגלוש אל הכתובת, ולראות שהכל עובד.

הכתובת היא

http://hostname/index.php?r=site/say&message=Hello+World

ואתה צריך לקבל דף שיראה כך :

אפליקצית שלום עולם ב- Yii
אפליקצית שלום עולם ב- Yii

 

הכתובת הזו הובילה לתוצאה של עמוד "Hello World". כאשר העמוד קיבל את אותו Header+fotter של שאר עמודי האפליקציה.

אם תמחק מה-URL את הפרמטר message, ותרענן את הדף, תוכל לראות שתתקבל המילה "Hello". זה מפני שהפרמטר message קיבל את המילה "Hello" בברירת מחדל בפונקציה actionSay.

כדאי לדעת : הדף החדש שיצרנו מקבל את אותו Header+Footer כמו שאר הדפים באפליקציה, כיוון שהמתודה render() מוסיפה אותם באופן אוטומטי לכל view, מתוך מה שנקרא layout, ומאוחסן במקרה שלנו במיקום views/layouts/main.php.

מה משמעות הפרמטר r בכתובת ?

הפרמטר r הוא קיצור של המילה route כלומר – ניתוב. זוהי הצורה ב-Yii לפנות אל action ספציפי. כאשר בכל פעם שנראה לפנות ל-action נציין זאת בתבנית הבאה ControllerID/ActionID.

ואז, כאשר האפליקציה מקבלת request היא בודקת את הפרמטר הזה, ופונה אל המחלקה של ה-ControllerID המתאים, ובתוכה אל המתודה של ה-ActionID המתאים, כדי לבצע את הפעולה שהתבקשה דרך ה-URL. בדוגמא שלנו, היא פנה אל ה-Controller שנקרא SiteController ובתוכו אל ה-Action שנקראת say . וכתוצאה, הפעלנו למעשה את המתודה  SiteController::actionSay() כדי לבצע את הפעולה.

חשוב לדעת : בדיוק כמו הכללים לכתיבת שמות של actions. גם ל-controllers יש כללים מחייבים עבור השמות שלהם. אותם כללים בדיוק. כלומר, שם המחלקה של ה-Controller מורכב ממילים בפורמט CamelCased (כל מילה מתחילה באות גדולה, ללא רווחים). ובסוף הביטוי יש להוסיף את המילה Controller.
לדוגמא : אם ה-Controller ID הוא post-comment, אזי שם המחלקה יקרא PostCommentController.

סיכום – אפליקצית "שלום עולם" ב-Yii.

במדריך הזה :

  • נגעת במושגים controller , view ששיכים לשיטת הפיתוח MVC.
  • יצרת action שהיא חלק מ-controller כדי לטפל ב-request מסוים.

במדריך הזה, לא נעשה שימוש ב-model כלל, והמידע היחיד שהשתמשנו בו, היה הפרמטר message.

בנוסף למדת על ניתוב (route) ב- Yii, שמהווה מעין גשר בין ה-request של המשתמש ובין המתודות (=actions) של ה-Controller.

בפרק הבא תלמד כיצד ליצור model. וכיצד להוסיף דפים חדשים הכוללים טפסי HTML.

 

זכויות יוצרים : המדריך פורסם לפי התנאים של Yii , והמקור נמצא בקישור הזה.

מדריך Yii – עבודה עם טפסים

אחרי המדריך הקודם, בו תיארנו את ה-Actions וה-Views , המדריך  זה מתאר איך ליצור דף חדש באתר,  עם טופס לקבלת נתונים ממשתמשים. בדף שניצור יהיה טופס עם 2 שדות : שם + אימייל. ואחרי שנקבל את הפרטים האלו מהגולש, נבדוק אותם, ונציג אותם חזרה למשתמש.

כדי לבצע את המשימה הזו – יצירת דף עם טופס, צריך ללמוד גם ליצור model (אחרי שלמדנו כבר על view, action ).

במדריך הזה נלמד :

  • ליצור model
  • איך רושמים כללים לאימות/validation של הנתונים במודל
  • לבנות טופס Html באמצעות Yii

יצירת מודל ב- Yii

הגולש יכניס נתונים לתוך טופס, את הנתונים, אנחנו נשמור בתוך מחלקה מסוג model  בקובץ  models/EntryForm.php. (אם אתה עדין לא מכיר את הכללים ליצירת שמות קבצים ומחלקות, עיין בסעיף AutoLoading).

<?php

namespace appmodels;

use yiibaseModel;

class EntryForm extends Model
{
    public $name;
    public $email;

    public function rules()
    {
        return [
            [['name', 'email'], 'required'],
            ['email', 'email'],
        ];
    }
}

 

המחלקה שיצרנו מרחיבה (extends) את המחלקה yiibaseModel , שהיא מחלקה בסיסית ש-Yii מספקת לנו, עבור מודלים.

הערה : המחלקה yiibaseModel משמשת ליצירת מודלים שלא מבוססים על DB, עבור מודלים שמבוססים על DB יש מחלקה אחרת שנקראת yiidbActiveRecord.

המחלקה EntryForm מכילה 2 משתנים ציבוריים : name,email. המשתנים האלו ישמשו לאחסון המידע שהגולש יקליד בטופס.

בנוסף, המודל מכיל גם מערך של כללים , המשמשים לבדיקת הנתונים (validition), יש שם 2 כללים :

  • 2 השדות הם חובה
  • האימייל חייב להיות אימייל תקין

נניח ויש לך אוביקט של EntryForm שמכיל כבר את הנתונים מהגולש, ואתה מעוניין רק לבדוק אותו , לעשות לו וואלידציה, אז הקוד יראה  כך  (אם הוואלידציה לא מצליחה, תקבל hasErrors  = false והשגיאות יופיעו באוביקט errors ) :

<?php
$model = new EntryForm();
$model->name = 'Qiang';
$model->email = 'bad';
if ($model->validate()) {
    // Good!
} else {
    // Failure!
    // Use $model->getErrors()
}

יצירת Action

כעת, צריך ליצור Action שיקרא Entry בתוך ה-Controller , כאשר ה-Action , יעשה שימוש במודל החדש שיצרנו.

<?php

namespace appcontrollers;

use Yii;
use yiiwebController;
use appmodelsEntryForm;

class SiteController extends Controller
{
    // ...existing code...

    public function actionEntry()
    {
        $model = new EntryForm;

        if ($model->load(Yii::$app->request->post()) && $model->validate()) {
            // valid data received in $model

            // do something meaningful here about $model ...

            return $this->render('entry-confirm', ['model' => $model]);
        } else {
            // either the page is initially displayed or there is some validation error
            return $this->render('entry', ['model' => $model]);
        }
    }
}

המתודה actionEntry , מתחילה בכך שהיא  יוצרת אובייקט EntryForm.
לאחר מכן, המתודה מנסה להכניס את הנתונים שהגיעו ב-Post אל תוכל המודל, ולשם כך המתודה נעזרת ב yiiwebRequest::post() שמסופק על yii.  אם המתודה מצליחה להכניס את הנתונים למודל היא קוראת לפונקציה validate() כדי לוודא שהנתונים שהוקלדו נכונים.

מידע: הביטוי  Yii::$app הוא מופע (instance) של אוביקט  application  (אוביקט עם מופע יחיד – סינגלטון).  הוא מאפשר לנו לגשת לאוביקטים חשובים, כמו כמו request, response, db. בדוגמא הספציפית שלנו, הוא איפשר לנו לגשת לאוביקט request ולמשוך מתוכו את הנתונים שהגיעו ב-Post.

אם הכל תקין בטופס, אז ה-Action תקרא לפונקציה render() כדי ליצור view בשם entry-confirm .

אם אין נתונים, או שהגולש הקליד נתונים שלא עומדים בכללי הוואלידציה, אז הפונקציה render() תייצר view אחר, שנקרא entry – שזהו בעצם הטופס עצמו, כלומר המשתמש מוחזר לטופס עם ציון השגיאות שעליו לתקן.

הערה: זוהי דוגמא ממש פשוטה, ולכן רק יצרנו "דף אישור" אחרי שהטופס עובר בהצלחה, אבל ברור שבמקרים אמיתיים, צריך להשתמש בפעולות אחרות, כמו למשל refresh() או redirect() , כדי להימנע מבעיות של שליחה-מחדש של טפסים.

יצירת Views

השלב האחרון במדריך הוא ליצור 2 קבצי view, אחד יקרא בשם entry-confirm  והשני יקרא פשוט entry. ה-view שיקרא entry-confirm פשוט מציג את הנתונים שהוקלדו בטופס.

צור קובץ במיקום views/site/entry-confirm.php :

<?php
use yiihelpersHtml;
?>
<p>You have entered the following information:</p>

<ul>
    <li><label>Name</label>: <?= Html::encode($model->name) ?></li>
    <li><label>Email</label>: <?= Html::encode($model->email) ?></li>
</ul>

הקובץ השני הוא views/site/entry.php והוא יכיל את טופס ה-html עצמו :

<?php
use yiihelpersHtml;
use yiiwidgetsActiveForm;
?>
<?php $form = ActiveForm::begin(); ?>

    <?= $form->field($model, 'name') ?>

    <?= $form->field($model, 'email') ?>

    <div class="form-group">
        <?= Html::submitButton('Submit', ['class' => 'btn btn-primary']) ?>
    </div>

<?php ActiveForm::end(); ?>

בקוד של ה-view הזה בטח הבחנת שאנו משתמשים ב-widget עוצמתי של Yii שנקרא ActiveForm כדי לבנות את טופס ה-Html. המתודות begin() ו- end() יוצרות את תגי הפתיחה והסיום של הטופס, והמתודה field() מציגה שדה בודד.

לסיום המתודה yiihelpersHtml::submitButton()  מייצרת כפתור Submit לשליחת הנתונים.

נסה את זה בעצמך

כדי לנסות את הטופס החדש באפליקציה גלוש אל

http://hostname/index.php?r=site/entry

אם תשחק עם הטופס ותנסה להקליד נתונים שגויים וללחוץ submit תראה שתקבל הודעות שגיאה, כמו בתמונה הבאה :

אך לעומת זאת אם תקליד נתונים שעומדים בכלל הוואלידציה תקבל את ה-view שיצרת שנקרא entry-confirm שנראה כך :

 איך הוודליאציה עובדת בלי רענון של הדף (מה הטריק ? )

הרכיב שנקרא yiiwidgetsActiveForm הוא רכיב חכם שמייצר בעצם 2 נדבכים של וואלידציה, הראשון הוא JavaScript , ורק במידה ואצל הגולש – ה-JS לא מופעל בדפדפן, אזי בכל מקרה, תהיה גם וואלידציה בצד השרת (php כמובן).

ותגיות ה-label מיוצרות אוטומטית באמצעות הפונקציה field().

אם אתה מעוניין לשנות את ה-labels, אפשר לשנות אותם בצורה הבאה:

<?= $form->field($model, 'name')->label('Your Name') ?>
<?= $form->field($model, 'email')->label('Your Email') ?>

הערה : Yii מספק הרבה widgets  כאלו שיעזרו לך לבנות במהירות אפליקציות ואתרים  מורכבים.גם לבנות בעצמך widgets זה קל מאוד.

 סיכום – טפסים ב-Yii

במדקיך הזה נגענו בכל החלקים של שיטת MVC. יצרנו מחלקה עבור model, שייצג את הנתונים שקיבלנו מהמשתמש. וראינו איך ליצור וואלידציה במודל.

בנוסף, ראינו איך ליצור טפסי Html ואיך להשתמש ב-widgets של Yii.
במדריך הבא, נראה איך לעבוד עם DBs .

המדריך מפורסם לפי התנאים של Yii , והמקור נמצא כאן .

 

 

 

מדריך Yii 2 – עבודה עם דאטאבייסים

במדריך הזה ניצור עמוד חדש שמציג תוכן של טבלה ב-DB בשם country. כדי לעשות זאת, אנחנו נגדיר את החיבור ל-DB ( כלומר connection), ניצור אוביקט של  Active Record , נגדיר action, וניצור view.

במדריך נעבור על הנושאים הבאים :

  • הגדרת connection אל הדאטאבייס
  • הגדרת אוביקט ActiveRecord
  • איך לבצע שאילתות על אוביקט ActiveRecord
  • איך להציג רשומות , עם חלוקה לעמודים (pagnition)

הנחת היסוד היא שיש לך ידע מסוים בדאטאבייסים, אתה צריך לדעת ליצור DB, להריץ פקודות SQL ולהשתמש באיזשהוא כלי ניהול של DB.

הכנת הדאטאבייס

כדי להתחיל, צור דאטאבייס בשם yii2basic שממנו נמשוך את הנתונים. אתה יכול ליצור אותו ב- SQLite, MySQL, PostgreSQL, MSSQL ,Oracle, לכולם יש תמיכה מובנית ב-Yii.

יחד עם זאת, בשביל הפשטות ההנחה לצורך המדריך הזה היא שאתה משתמש ב-MySql.

שלב שני, הרץ את הפקודות הבאות, שיוצרות טבלה בשם country, ומכניסות לה מספר רשומות.

CREATE TABLE `country` (
  `code` CHAR(2) NOT NULL PRIMARY KEY,
  `name` CHAR(52) NOT NULL,
  `population` INT(11) NOT NULL DEFAULT '0'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `country` VALUES ('AU','Australia',18886000);
INSERT INTO `country` VALUES ('BR','Brazil',170115000);
INSERT INTO `country` VALUES ('CA','Canada',1147000);
INSERT INTO `country` VALUES ('CN','China',1277558000);
INSERT INTO `country` VALUES ('DE','Germany',82164700);
INSERT INTO `country` VALUES ('FR','France',59225700);
INSERT INTO `country` VALUES ('GB','United Kingdom',59623400);
INSERT INTO `country` VALUES ('IN','India',1013662000);
INSERT INTO `country` VALUES ('RU','Russia',146934000);
INSERT INTO `country` VALUES ('US','United States',278357000);

כעת, יש לך כבר דאטאבייס שנקרא yii2basic ובתוכו לפחות טבלה אחת בשם country עם כמה עמודות ו-10 רשומות.

הגדרת החיבור לדאטאבייס (database connection)

לפני שנמשיך, נא וודא ש-php  מותקנת אצלך עם התוספת שנקראת PDO, זוהי דרישת חובה כדי ש-Yii תוכל לתקשר עם דאטבייס רלציוני.

בהנחה ש-PDO מותקנת אצלך, פתח את הקובץ config/db.php ושנה את הפרמטרים הנחוצים כדי ליצור חיבור עם הדאטאבייס על השרת שלך.

<?php
// שנה את מה שצריך כאן
return [
    'class' => 'yiidbConnection',
    'dsn' => 'mysql:host=localhost;dbname=yii2basic',
    'username' => 'root',
    'password' => '',
    'charset' => 'utf8',
];

הקובץ config/db.php הוא כלי הגדרה, שעוזר לאתחל ברקע מופע (instance) של אוביקט  yiidbConnection כדי שיהיה אפשר לתקשר עם הדאטאבייס.

אם אתה צריך לגשת לאוביקט הקונקשיין תוך כדי ריצה, תוכל לעשות זאת בפניה אל  Yii::$app->db.

הערה : הקובץ config/db.php נמשך (include) על ידי הקובץ  config/web.php שמאתחל את האוביקט  application. להרחבה בנושא הגדרות, בקר בקישור  Configurations.

 יצירה של ActiveRecord

כדי לגשת למידע מתוך הטבלה country, עלינו ליצור מחלקת בת של Active Record בשם של הטבלה – Country ולשמור את זה בקובץ models/Country.php.

<?php

namespace appmodels;

use yiidbActiveRecord;

class Country extends ActiveRecord
{
}

המחלקה Country מרחיבה (extends) את המחלקה  yiidbActiveRecord. בעיקרון , אתה לא צריך לרשום כלום בתוך המחלקה, כי Yii "תנחש" את הטבלה המשויכת למודל זה לבד.

הערה : אם אין סיכוי לנחש את השם מתוך שם ה-class, אתה יכול להגדיר את שם הטבלה בעצמך באמצעות המתודה yiidbActiveRecord::tableName().

עכשיו, אחרי שיש לנו מחלקה בשם Country, יהיה קל יותר לגשת למידע ולעשות מניפולציות עליו.

הנה כמה דוגמאות קוד לשליפת נתונים וגישה אליהם :

 

use appmodelsCountry;

// לשלוף את כל הרשומות מהטבלה ולמיין אותן לפי השדה name
$countries = Country::find()->orderBy('name')->all();

// שלוף את כל הרשומות עם מפתח ראשי שהוא US
$country = Country::findOne('US');

// להציג תוכן של שדה
echo $country->name;

// לשנות ערך בשדה ולשמור את השינוי בדאטאבייס
$country->name = 'U.S.A.';
$country->save();

הערה : גישה לנתונים באמצעות ActiveRecord היא דרך מאוד עוצמתית, מונחית עצמים. למידע נוסף בקר בקישור הבא :  Active Record

כדאי לדעת שיש אפשרות לבצע שאילתות בצורה "גולמית" יותר עם אוביקט אחר שנקרא Data Access Objects.

יצירת Action

כדי להציג לגולשים את תוכן הטבלה country, אנחנו צריכים ליצור action חדש. הפעם, במקום ליצור אותו בתוך ה-controller שנקרא site, אנחנו ניצור אותו בתוך controller חדש, שיהיה שייך ספציפית לטבלה הזו, ונקרא לו בשם CountryController, בתוך הקונטרולר החדש, ניצור מתודה/action בשם index כמו שמוצג בקוד הבא :

<?php

namespace appcontrollers;

use yiiwebController;
use yiidataPagination;
use appmodelsCountry;

class CountryController extends Controller
{
    public function actionIndex()
    {
        $query = Country::find();

        $pagination = new Pagination([
            'defaultPageSize' => 5,
            'totalCount' => $query->count(),
        ]);

        $countries = $query->orderBy('name')
            ->offset($pagination->offset)
            ->limit($pagination->limit)
            ->all();

        return $this->render('index', [
            'countries' => $countries,
            'pagination' => $pagination,
        ]);
    }
}

שמור את קטע הקוד הזה בקובץ  controllers/CountryController.php.

מה בעצם קורה בקוד ? המתודה/action שנקראת index קוראת ל Country::find() שזוהי מתודה מובנית לביצוע שאילתות DB , וכך מחזירה מידע מתוך הטבלה country .

כדי להגביל את מספר הרשומות המוצגות על המסך (ארצות במקרה זה) , אנחנו משתמשים באוביקט עימוד – yiidataPagination שמבצע מניפולציה על השאילתא, כך שנחזיר רק חלק מהרשומות – רק כמות מסוימת שנרצה להציג על המסך.

האוביקט הזה –yiidataPagination  יכול לסייע לנו בכמה צורות :

  • הוא מוסיף פסויקיות LIMIT ו-OFFSET למשפט ה-SQL של השאילתא. (במקרה שלנו הגבלנו ל-5 רשומות בכל דף).
  • הוא מאפשר להוסיף ל-view סט  של כפתורים לדילוג בין עמודים (1,2 וכו…)

בסוף הפונקציה index, אנו קוראים ל-render כדי ליצר view שנקרא index ומעבירים אליו את חבילת המידע על country, ביחד עם אוביקט העימוד שיצרנו.

יצירת ה-view

עכשיו, צור תיקיה חדשה תחת תיקית views וקרא לה country. התיקיה הזו תכיל את כל ה-views שקשורים לקונטרולר country. בתוך תיקית views/country צור קובץ חדש וקרא לו index.php ובתוכו הדבק את הקוד הבא :

<?php
use yiihelpersHtml;
use yiiwidgetsLinkPager;
?>
<h1>Countries</h1>
<ul>
<?php foreach ($countries as $country): ?>
    <li>
        <?= Html::encode("{$country->name} ({$country->code})") ?>:
        <?= $country->population ?>
    </li>
<?php endforeach; ?>
</ul>

<?= LinkPager::widget(['pagination' => $pagination]) ?>

ל-view יש 2 חלקים : החלק הראשון מציג את הרשומות מתוך הטבלה country בתור "רשימה" של html.

והחלק השני  יש widget של Yii שנותן את כפתורי מעבר בין עמודים. הוא נקרא yiiwidgetsLinkPager  .

נסה את זה בעצמך

כדי לראות את כל הקוד בפעולה, גלוש אל

http://hostname/index.php?r=country/index

זה צריך להיראות כך :

בראש הדף אתה תראה 5 מדינות, ומתחת להן, יופיעו כפתורי העימוד. אם תקליק על אחד מכפתורי העימוד, תראה כיצד מופיעות רשומות אחרות בהתאמה, ואם תשים לב, תראה שגם הכתובת בדפדפן משתנה בהתאם.

לדוגמא , עבור העמוד השני , הכתובת שתופיע היא :

http://hostname/index.php?r=country/index&page=2

 

מאחורי הקלעים, אוביקט העימוד – Pagination , מספק את כל היכולות הדרושות כדי שזה יקרה :

  • בתחילה, אוביקט Pagination מציג את העמוד הראשון, באמצעות פסוקית SQL  הבאה לסוף המשפט LIMIT 5 OFFSET 0. , כתוצאה מכך נקבל את 5 המדינות הראשונות.
  • רכיב ה-  LinkPager מרנדר את הכפתורים למטה, כשכל כפתור מכיל URL עם פרמטר page לעמוד אחר.
  • כאשר אנו מקליקים על "2" לדוגמא, אז אוביקט ה- Pagination מקבל את הפרמטר, ומוסיף לסוף משפט ה-SQL את הפסוקית LIMIT 5 OFFSET 5 ומחזיר את המדינות הבאות בהתאם.

סיכום – עבודה עם דאטאבייסים ב- Yii 2

במדריך הזה למדת כיצד לעבוד עם דאטאבייס, בנוסף למדת על השימוש באוביקט yiidataPagination , וברכיב ה yiiwidgetsLinkPager .

במדריך הבא נראה איך להשתמש בכלי ה-Gii, כלי עוצמתי של Yii המאפשר לחסוך המון זמן באמצעות כך שהוא בונה עבורך חלקים שלמים באפליקציה – מודלים, CRUD, ועוד.

המדריך מפורסם לפי התנאים של Yii, והמקור נמצא כאן

 

מדריך Yii 2 – עבודה עם Gii – כלי ליצירה אוטומטית של קוד

במדריך הקודם, דיברנו עם עבודה עם דאטאבייסים ב-Yii, במדריך הזה נציג כלי מדהים שנקרא Gii שמקל מאוד על משימות שגרתיות בפיתוח האפליקציה.

Gii הוא מחולל קוד אוטומטי, שמאפשר בצורה פשוטה מאוד, רק צריך להקליד את המידע הנכון בשדות הנכונים, כמה לחיצות, והקוד מיוצר אוטומטית.

במדריך הזה נלמד :

  • איך לאפשר את הפעלת הכלי Gii בשרת הפיתוח שלך
  • ליצור מחלקת ActiveRecord באמצעות Gii
  • ליצור את כל פעולות ה-CRUD באמצעות Gii
  • שינוי של קוד שנוצר ב-Gii

איך להפעיל את המודול Gii

Gii הוא מודול של Yii. וכדי להפעיל אותו, צריך לפני כן לאפשר אותו. בעיקרון , ברירת המחדל של קובץ ההגדרות נמצאת ב : config/web.php , היכנס לשם, ותשנה את השורות הרלוונטיות :

$config = [ ... ];

if (YII_ENV_DEV) {
    $config['bootstrap'][] = 'gii';
    $config['modules']['gii'] = 'yiigiiModule';
}

כמו שבוודאי שמת לב, התנאי בקטע הקוד בודק האם המשתנה YII_ENV_DEV הוא true, ואם כן, מפעיל את המודול.

משתנה זה הוא משתנה שקובע האם אתה בסביבת פיתוח או יצור (production). ואם הסביבה היא סביבת פיתוח, אז האפלקציה עושה include למחלקה שהיא המודול הזה – מחלקת yiigiiModule.

אז כדי לוודא שהמשתנה הזה מכוון אצלך על סביבת פיתוח, עליך לבדוק ש בקובץ  web/index.php (מה שנקרא entry script - הכוונה לסקריפט שדרכו מנותבת כל התנועה ב Yii) 

מופיעה ההגדרה הבאה שקובעת את ערך המשתנה ל-true  :

defined('YII_ENV') or define('YII_ENV', 'dev');

השורה הזו קובעת בפועל שאתה ב-development mode  והכלי Gii מאופשר.

עכשיו אתה יכול לגלוש אל הכלי :

http://hostname/index.php?r=gii

שים לב : אם אתה עובד על שרת שאיננו localhost , אזי Gii יחסם אוטמטית, מטעמי אבטחה. אם תרצה לאפשר זאת על השרת, תצטרך לציין IP של השרת בהגדרה הבאה :

'gii' => [
    'class' => 'yiigiiModule',
    'allowedIPs' => ['127.0.0.1', '::1', '192.168.0.*', '192.168.178.20'] // adjust this to your needs
],

 

וכך נראה הכלי Gii – במסך הכניסה : 

 

2 הערות חשובות לפני שמתקדמים

  1. הכלי הולך לייצר קבצים, אז אם שרת הפיתוח שלך מבוסס לינוקס, כדאי לוודא שיש ליוזר של אפצ'ה הרשאות כתיבה מלאות.
  2. במידה ואתה מייצר הרבה קבצים, וחלקם דורסים קבצים ישנים יותר, שים לב שאתה מסמן כל מה שצריך ב-overwrite, אחרת תקבל הודעות שגיאה.

איך לייצר מחלקה של Active Record באמצעות Gii ?

כדי להשתמש ב-Gii ליצור class של Active Record, בחר ב-Model Generator, ואז מלא את הפרטים הבאים בטופס :

  • Table Name: country
  • Model Class: Country

וכך זה צריך להיראות : 

 

עכשיו, לחץ על Preview, אתה תראה את הקובץ models/Country.php ברשימת התוצאות, אתה יכול ללחוץ על שם הקובץ אם אתה רוצה לראות את תוכנו – הקוד עצמו.

כאשר משתמשים ב-Gii, אם יש קובץ קודם בעל אותו שם – הוא ידרס, אם רוצים לראות את ההבדלים בקוד לעומת הגירסה הקודמת, לחץ diff .

השלב הבא הוא ללחוץ על Generate, ואז לאשר את ה-overwrite.

יצירת CRUD עם הכלי Gii

המונח CRUD מתאר את הפעולות הבסיסיות בדאטאבייס – יצירה, קריאה, עדכון ומחיקה, וניתן ליצור את כל רצף ה-actions וה-view עם המודל והקונטרולר במהירות באמצעות Gii.

כדי לעשות זאת לחץ על CRUD Generator, ואם נמשיך עם הדוגמא של טבלת Country, אז צריך למלא את הערכים הבאים :

  • Model Class: appmodelsCountry
  • Search Model Class: appmodelsCountrySearch
  • Controller Class: appcontrollersCountryController

זה צריך להיראות כך :

והמסך הבא (אחרי לחיצה על Preview) נראה כך : 

אם יצרת במדריכים הקודמים את הקונטרולר ואת ה-Index, אז תצטרך לאשר דריסה (overwrite) אחרי לחיצה על Generate.

 נסה את זה בעצמך

כדי לראות את כל מה שנוצר , גלוש אל

http://hostname/index.php?r=country/index

 

אתה תראה רשימה של המדינות, כאשר יש מעל כל עמודה אפשרות חיפוש, ולצד כל עמודה מופיעות האפשרויות לערוך, למחוק ולצפות.

 

אפשרות העדכון נראית כך : 

 

הקבצים שנוצרו על ידי Gii הם הקבצים הבאים, אתה מוזמן להיכנס אליהם ולשנות אותם לפי הצורך :

  • Controller: controllers/CountryController.php
  • Models: models/Country.php and models/CountrySearch.php
  • Views: views/country/*.php

מידע: Gii נועד להיות כלי יצירת קוד אוטומטי, כדי לאפשר לך התאמה אישית של הקוד והרחבה. אם תשתמש בו בתבונה, תוכל להאיץ את מהירות הפיתוח משמעותית.

סיכום – שימוש בכלי Gii של Yii

בסעיף זה ראית כיצד להשתמש בחלק מיכולותיו של Gii, בין השאר גם לחולל את פעולות ה-CRUD.

 

המדריך מפורסם לפי התנאים של Yii, והמקור נמצא כאן

התקנת Yii 2 על linux עם php composer

במדריך הזה, אני מראה איך להתקין את Yii 2 על לינוקס עם composer.

  • פתח תיקיה חדשה בתיקית ה-web שלך.
  • דאג שיהיו לך הרשאות מתאימות לתיקיה (chown/ chmod )
  • מתוך התיקיה – הקלד את הפקודות הבאות  ב-console כדי להוריד את ה-composer אל תוך התיקיה, וכדי להתקין אותה במצב "גלובלי"
sudo curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
  • השלב הבא הוא להוריד פלאגאין ל-Composer ולהתקין אותו
    כיוון שהעברנו את ה-composer לתיקיה אחרת, ושינינו את שם הקובץ, הפקודה תהיה כך :
sudo php /usr/local/bin/composer global require "fxp/composer-asset-plugin:1.0.0-beta3"
  • עכשיו – אם יש לך חשבון GitHub, אז תיזכר בשם משתמש והסיסמא, ואם לא – אז פתח לעצמך חשבון.
  • ועכשיו הרץ את הפקודה הבאה ב-Console :
sudo php /usr/local/bin/composer create-project yiisoft/yii2-app-basic basic 2.0.0
  • ה-composer יתחיל בהתקנה ויתכן שידרוש להקליד את שם המשתמש והסיסמא ב-Git.

בסיום ההתקנה – אתם מוזמנים לגלוש אל הפרויקט שהותקן.

הערה : בדוגמא התקנו את פרויקט basic של Yii, יש גם אפשרות להתקין פרויקט advanced.

המדריך מפורסם לפי התנאים של Yii, והמקור נמצא כאן, במקרה זה בוצעו מספר שינויים בתרגום להתאמה ל-ubuntu