Erstellen Sie eine Hochzeitsplanungs-Website mit dem Yii-Framework

Die Hochzeit ist ein wichtiger Moment im Leben eines jeden Menschen. Für die meisten Menschen ist eine schöne Hochzeit sehr wichtig. Bei der Planung einer Hochzeit achtet das Paar nicht nur auf die Größe und Pracht der Hochzeit, sondern legt auch mehr Wert auf die Details und das persönliche Erlebnis der Hochzeit. Um dieses Problem zu lösen, haben viele Hochzeitsplanungsunternehmen ihre eigenen Websites eingerichtet und entwickelt. In diesem Artikel wird erläutert, wie Sie mit dem Yii-Framework eine Website zur Hochzeitsplanung erstellen.

Yii-Framework ist ein leistungsstarkes PHP-Framework, das von Entwicklern wegen seiner Einfachheit und Benutzerfreundlichkeit sehr geschätzt wird. Mithilfe des Yii-Frameworks können wir eine qualitativ hochwertige Website effizienter entwickeln. Im Folgenden wird erläutert, wie Sie mit dem Yii-Framework eine Website zur Hochzeitsplanung erstellen.

Schritt 1: Installieren Sie das Yii-Framework
Zuerst müssen wir das Yii-Framework installieren. Sie können es über Composer installieren:

composer create-project --prefer-dist yiisoft/yii2-app-basic basic

oder das komprimierte Yii-Framework-Paket herunterladen und in das Serververzeichnis extrahieren. Führen Sie nach dem Entpacken den folgenden Befehl aus, um die erforderlichen Abhängigkeiten zu installieren:

php composer.phar install

Schritt 2: Datenbank und entsprechende Tabellen erstellen
Im vorherigen Schritt haben wir das Yii-Framework erfolgreich installiert. Als nächstes müssen Sie die Datenbank und die entsprechenden Tabellen erstellen. Es kann direkt über Tools wie MySQL Workbench erstellt werden.

Erstellen Sie eine Datenbank mit dem Namen Wedding und erstellen Sie dann eine Tabelle mit der folgenden Struktur:

CREATE TABLE IF NOT EXISTS `user` (
    `id` INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    `username` VARCHAR(255) NOT NULL,
    `password_hash` VARCHAR(255) NOT NULL,
    `email` VARCHAR(255) NOT NULL,
    `auth_key` VARCHAR(255) NOT NULL,
    `status` SMALLINT NOT NULL DEFAULT 10,
    `created_at` INT NOT NULL,
    `updated_at` INT NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE IF NOT EXISTS `article` (
    `id` INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    `title` VARCHAR(255) NOT NULL,
    `content` TEXT NOT NULL,
    `status` SMALLINT NOT NULL DEFAULT 10,
    `created_at` INT NOT NULL,
    `updated_at` INT NOT NULL,
    `user_id` INT UNSIGNED NOT NULL,
    CONSTRAINT `fk_article_user_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Unter diesen speichert die Benutzertabelle Benutzerinformationen und die Artikeltabelle speichert Artikelinformationen.

Schritt 3: Modell erstellen
Im Yii-Framework ist das Modell Teil des M (Modell) in der MVC-Architektur und für die Datenverarbeitung verantwortlich. Wir müssen zwei Modelle erstellen, User und Article:

class User extends ActiveRecord implements IdentityInterface
{
    public static function findIdentity($id)
    {
        return static::findOne($id);
    }

    public static function findIdentityByAccessToken($token, $type = null)
    {
        throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
    }

    public function getId()
    {
        return $this->getPrimaryKey();
    }

    public function getAuthKey()
    {
        return $this->auth_key;
    }

    public function validateAuthKey($authKey)
    {
        return $this->getAuthKey() === $authKey;
    }

    public static function findByUsername($username)
    {
        return static::findOne(['username' => $username, 'status' => self::STATUS_ACTIVE]);
    }

    public function validatePassword($password)
    {
        return Yii::$app->security->validatePassword($password, $this->password_hash);
    }
}

class Article extends ActiveRecord
{
    public function getUser()
    {
        return $this->hasOne(User::className(), ['id' => 'user_id']);
    }
}

Im obigen Code haben wir zwei Modelle definiert, User und Article, indem wir die ActiveRecord-Klasse geerbt haben. Das User-Modell implementiert die IdentityInterface-Schnittstelle zur Identitätsauthentifizierung; das Article-Modell definiert die Beziehung zwischen Benutzern und Artikeln über die Methode getUser().

Schritt 4: Controller und Ansichten erstellen
Im Yii-Framework ist der Controller Teil des C (Controller) in der MVC-Architektur und für die Verarbeitung empfangener Webanfragen verantwortlich. Wir müssen zwei Controller erstellen: UserController und ArticleController sowie entsprechende Ansichten.

UserController wird für die Benutzerregistrierung, Anmeldung und andere Vorgänge verwendet:

class UserController extends Controller
{
    public function actionSignup()
    {
        $model = new SignupForm();

        if ($model->load(Yii::$app->request->post()) && $model->signup()) {
            Yii::$app->session->setFlash('success', 'Thank you for registration. Please check your inbox for verification email.');
            return $this->goHome();
        }

        return $this->render('signup', [
            'model' => $model,
        ]);
    }

    public function actionLogin()
    {
        $model = new LoginForm();

        if ($model->load(Yii::$app->request->post()) && $model->login()) {
            return $this->goBack();
        }

        return $this->render('login', [
            'model' => $model,
        ]);
    }

    public function actionLogout()
    {
        Yii::$app->user->logout();

        return $this->goHome();
    }
}

ArticleController wird für die Bearbeitung, Anzeige und andere Vorgänge von Artikeln verwendet:

class ArticleController extends Controller
{
    public function behaviors()
    {
        return [
            'access' => [
                'class' => AccessControl::className(),
                'only' => ['create', 'update'],
                'rules' => [
                    [
                        'actions' => ['create', 'update'],
                        'allow' => true,
                        'roles' => ['@'],
                    ],
                ],
            ],
            'verbs' => [
                'class' => VerbFilter::className(),
                'actions' => [
                    'delete' => ['POST'],
                ],
            ],
        ];
    }

    public function actionIndex()
    {
        $dataProvider = new ActiveDataProvider([
            'query' => Article::find(),
        ]);

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

    public function actionView($id)
    {
        return $this->render('view', [
            'model' => $this->findModel($id),
        ]);
    }

    public function actionCreate()
    {
        $model = new Article();

        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            return $this->redirect(['view', 'id' => $model->id]);
        }

        return $this->render('create', [
            'model' => $model,
        ]);
    }

    public function actionUpdate($id)
    {
        $model = $this->findModel($id);

        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            return $this->redirect(['view', 'id' => $model->id]);
        }

        return $this->render('update', [
            'model' => $model,
        ]);
    }

    public function actionDelete($id)
    {
        $this->findModel($id)->delete();

        return $this->redirect(['index']);
    }

    protected function findModel($id)
    {
        if (($model = Article::findOne($id)) !== null) {
            return $model;
        }

        throw new NotFoundHttpException('The requested page does not exist.');
    }
}

Im obigen Code verwenden wir einige integrierte Komponenten und Vorgänge von Yii , wie AccessControl, ActiveDataProvider , VerbFilter usw., um effizienter zu entwickeln.

Schritt 5: Routing und Datenbank konfigurieren
Im Yii-Framework müssen die Routing-Konfiguration und die Datenbankverbindungskonfiguration in der Konfigurationsdatei konfiguriert werden. Wir müssen die folgenden zwei Dateien bearbeiten:

/config/web.php:

return [
    'id' => 'basic',
    'basePath' => dirname(__DIR__),
    'bootstrap' => ['log'],
    'components' => [
        'request' => [
            'csrfParam' => '_csrf',
        ],
        'user' => [
            'identityClass' => 'appmodelsUser',
            'enableAutoLogin' => true,
        ],
        'session' => [
            // this is the name of the session cookie used for login on the frontend
            'name' => 'wedding_session',
        ],
        'log' => [
            'traceLevel' => YII_DEBUG ? 3 : 0,
            'targets' => [
                [
                    'class' => 'yiilogFileTarget',
                    'levels' => ['error', 'warning'],
                ],
            ],
        ],
        'urlManager' => [
            'enablePrettyUrl' => true,
            'showScriptName' => false,
            'rules' => [
                '' => 'article/index',
                '<controller>/<action>' => '<controller>/<action>',
                '<controller>/<action>/<id:d+>' => '<controller>/<action>',
            ],
        ],
        'db' => require __DIR__ . '/db.php',
    ],
    'params' => $params,
];

Im obigen Code müssen Sie die Datenbank, das URL-Routing und andere Informationen konfigurieren, damit das Projekt reibungslos laufen kann. Die Datenbankverbindungsinformationen müssen in der Datei /config/db.php konfiguriert werden, damit das Yii-Framework mit der Datenbank interagieren kann.

Schließlich müssen wir auch die E-Mail-Versandinformationen in /config/params.php konfigurieren, damit Benutzer nach erfolgreicher Registrierung Bestätigungs-E-Mails erhalten können.

Zu diesem Zeitpunkt haben wir den gesamten Prozess der Erstellung einer Hochzeitsplanungs-Website mit dem Yii-Framework abgeschlossen. Durch die Einleitung dieses Artikels haben Sie bereits die grundlegende Verwendung des Yii-Frameworks verstanden und erfahren, wie Sie eine einfache Website zur Hochzeitsplanung erstellen. Wenn Sie eine komplexere und professionellere Hochzeitswebsite erstellen möchten, müssen Sie sich weiter mit dem Yii-Framework vertraut machen, um Webanwendungen effizienter zu entwickeln.

Das obige ist der detaillierte Inhalt vonErstellen Sie eine Hochzeitsplanungs-Website mit dem Yii-Framework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!