Статьи

Создание веб-приложений с нуля с Laravel — Eloquent ORM

Февраль 8, 2019

В этой мини-серии Nettuts + мы создадим веб-приложение с нуля, в то же время погрузившись в великолепную новую среду PHP, которая быстро набирает обороты и называется Laravel .

В этом уроке мы будем работать над неотъемлемой частью любого веб-приложения: моделями. Попутно мы узнаем об удивительной реализации ORM в Laravel: Eloquent.

Рассмотрение

Добро пожаловать в наши веб-приложения с нуля с серией Laravel ! В первом уроке серии мы узнали много нового о Laravel и его философии:

  • Что такое Laravel
  • Что отличает Laravel от других PHP-фреймворков
  • Где скачать Laravel
  • Как настроить Laravel
  • Как работает система маршрутизации Laravel
  • Некоторые другие функции в системе маршрутизации Laravel
  • Как создать свой первый контроллер Laravel
  • Некоторые дополнительные функции с контроллерами Laravel
  • Как создать свой первый Laravel View
  • Как использовать Laravel’s Blade Templating Engine

Если вы еще не читали его, вам следует взглянуть на предыдущий урок и прочитать его — это облегчит понимание философии Laravel и большей части того, что мы обсуждаем в этом уроке.

Во второй части серии Laravel мы создадим важную часть нашего тестового веб-приложения Instapics , которое является реализацией модели. Без дальнейших церемоний, давайте начнем!

Что такое «модели»?

Я уже немного говорил о том, что такое Модели , в одной из моих предыдущих статей, Zend Framework из Scratch — Модели и Интеграция Доктрины ORM , поэтому, чтобы не повторяться, я напишу суть того, что я написал здесь ранее. Не стесняйтесь обращаться к другому учебному пособию и читать больше о том, что есть модели.

Резюме:

  • Модели являются представителями базы данных и должны быть там, где находится вся бизнес-логика приложения.
  • Контроллеры связываются с моделями и просят их получить необходимую им информацию.
  • Эта информация затем передается контроллером в представление и отображается
  • Очень редко модель напрямую взаимодействует с представлением, но иногда это может происходить при необходимости
  • Модели могут общаться с другими моделями и не являются самодостаточными. У них есть отношения, которые переплетаются друг с другом
  • Эти отношения облегчают и ускоряют получение информации контроллером, поскольку он не должен взаимодействовать с различными моделями — модели могут делать это сами

Модели в Laravel или в большинстве фреймворков разрабатываются одинаково. Разница в том, что Laravel дает нам простой способ построения этих моделей, предоставляя нам методы общего назначения, которые понадобятся большинству моделей — Eloquent ORM .

Красноречивый ОРМ

ORM — это объектно-реляционный картограф, а у Laravel есть тот, который вам обязательно понравится! Он называется «Eloquent», потому что он позволяет вам работать с объектами базы данных и связями, используя красноречивый и выразительный синтаксис.

Eloquent ORM — это встроенная реализация Laravel ORM. На мой взгляд, это одна из лучших реализаций ORM, которую я когда-либо видел — конкурирует даже с Doctrine ORM. Это невероятно элегантно, использует стандартные отраслевые соглашения для уменьшения конфигурации.

Условные обозначения

Например, при использовании модели Eloquent предполагается, что таблица, которую представляет модель, имеет поле id . id является первичным ключом для любой записи и используется большинством методов Eloquent.

Eloquent правильно предполагает, что имя вашей таблицы — это форма вашей модели во множественном числе. Например, ваша модель User будет ссылаться на таблицу users . Поскольку для некоторых это не всегда является стандартом, Laravel предоставляет способ переопределить это: просто используйте флаг $table :

1
2
3
class User extends Eloquent {
    public static $table = ‘my_users’;
}

Это будет указывать Laravel не использовать соглашение и вместо этого использовать указанную таблицу.

Наконец, Laravel также может автоматизировать создание и обновление временных меток для нас. Для этого добавьте в таблицу столбец созданный и / или updated_at и установите флаг $timestamp в модели:

1
2
3
class User extends Eloquent {
    public static $timestamps = true;
}

Eloquent увидит флаг и автоматически установит поле created_at при создании, а также обновит поле updated_at каждом обновлении записи. Довольно круто, а?

Быстрый поиск

Извлечение записей очень просто с помощью методов поиска Eloquent. Например, вам нужно найти конкретную запись пользователя? Просто сделать:

1
$user = User::find($user_id);

Это возвращает модель User которой вы можете выполнять операции! Нужно использовать условные выражения? Давайте представим, что вы хотите получить пользователя по адресу электронной почты. Чтобы выполнить эту задачу, вы можете сделать что-то вроде:

1
$user = User::where(’email’, ‘=’, $email)->first();

В качестве альтернативы вы можете использовать динамические методы Laravel:

1
$user = User::where_email($email)->first();

Простые вставки и обновления

Вставка и обновление моделей с использованием Eloquent можно выполнить в три этапа.

  • Шаг 1 — Получить / Создать модель.

    1
    2
    3
    $user = new User();
           //or get an existing user
           $user = User::get($user_id);
  • Шаг 2 — Установите данные

    1
    2
    $user->email = ‘[email protected]’;
           $user->password = ‘test1234’;
  • Шаг 3 — Сохранить

    1
    $user->save();
  • Выполнено!

И, наконец, определение отношений.

Eloquent делает процесс определения отношений и поиска связанных моделей простым и интуитивно понятным.

Черт возьми, это так! Eloquent поддерживает три типа отношений:

  1. Один к одному
  2. Один ко многим
  3. Многие-ко-многим

Чтобы определить отношения между моделями, вам нужно создать метод в обеих моделях, который «описывает» их отношения. Например, допустим, у User User_Profile . Вы можете сделать это, определив метод user_profile в модели User :

1
2
3
4
5
6
class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one(‘User_Profile’);
    }
}

Поскольку здесь User является нашей «доминирующей» моделью (т. User_Profile belongs_to пользователя есть профиль, а у пользователя нет профиля), мы определяем, что User_Profile belongs_to User :

1
2
3
4
5
6
class User_Profile extends Eloquent {
    public function user()
    {
        return $this->belongs_to(‘User’);
    }
}

После того как мы определили эти отношения, мы можем сделать:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
/*
  Get the User_Profile object of a User
  This executes two SQL queries:
   
  SELECT * FROM `users` WHERE `id` = $user_id
  SELECT * FROM `user_profiles` WHERE `user_id` = $user_id
*/
$user = User::find($user_id);
$user_profile = $user->user_profile;
 
/*
  We can also do it the other way around
*/
$user_profile = User_Profile::where(‘user_id’, ‘=’, $user_id)->first();
$user = $user_profile->user;

Здесь следует отметить еще одно соглашение: Eloquent предполагает, что внешний ключ, используемый в User_Profile является именем ссылочной таблицы + _id . Опять же, если вы хотите изменить это поведение, вы можете переопределить его:

1
2
3
4
5
6
class User extends Eloquent {
    public function user_profile()
    {
        return $this->has_one(‘User_Profile’, ‘user_profile_user_id’);
    }
}

Допустим, мы хотим определить отношения между User и его загрузкой Photo . Это отношение один-ко-многим , в отличие от отношения User Profile который был один к одному . Мы знаем, что один User has_many загружает Photo , поэтому:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
class User extends Eloquent {
    public function photos()
    {
        return $this->has_many(‘Photo’);
    }
}
…
…
…
class Photo extends Eloquent {
    public function user()
    {
        return $this->belongs_to(‘User’);
    }
}

Основное отличие здесь от has_one состоит в том, что функция, которую мы будем использовать для получения фотографий пользователя, теперь будет возвращать массив объектов Photo . Итак, если мы хотим получить все фотографии пользователя, мы можем сделать:

1
2
3
4
5
6
$photos = User::find($user_id)->photos;
foreach($photos as $photo) {
    …
    …
    …
}

Нет, ссылка на photos как на имущество не является опечаткой. Ларавел дает нам немного сахара. Мы также могли бы сделать:

1
$photos = User::find($user_id)->photos()->get();

Отношения Мант-ко-многим

Этот вариант немного сложен, но, будучи реализованным, он позволяет легко обрабатывать отношения « многие ко многим» между моделями. Представим, например, что у вас снова есть модель User , и у каждого из этих пользователей может быть несколько Groups . Group также может иметь несколько Users . Мы будем использовать три таблицы для представления этих конкретных отношений:

  • Пользователи — таблица, где находятся все наши пользователи
  • Группы — таблица, где находятся все наши группы
  • Group User — таблица, в которой перечислены все пользователи в группе

Соглашение о структуре таблиц, которое будет искать Eloquent, будет примерно таким:

  • пользователи
    • Я бы
    • … другие столбцы
  • группы
    • Я бы
    • … другие столбцы
  • group_user
    • Я бы
    • ID пользователя
    • group_id
    • … другие столбцы

Еще одно соглашение, которое следует здесь отметить, заключается в том, что промежуточная таблица group_user — это имена двух таблиц, которые она соединяет, в алфавитном порядке с подчеркиванием. Как всегда, мы можем переопределить это.

Вот как будет выглядеть код внутри каждой из моделей для этих трех таблиц:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class User extends Eloquent {
    public function groups()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to(‘Group’, ‘group_listings’);
         
        return $this->has_many_and_belongs_to(‘Group’);
    }
}
…
…
…
class Group extends Eloquent {
    public function users()
    {
        //if we wanted to override the default naming convention
        //for the intermediate table, we can do it like so:
        //return $this->has_many_and_belongs_to(‘User’, ‘group_listings’);
         
        return $this->has_many_and_belongs_to(‘User’);
    }
}
…
…
…
class Group_User extends Eloquent {
    public function group()
    {
        return $this->has_one(‘Group’);
    }
     
    public function user()
    {
        return $this->has_one(‘User’);
    }
}

Имея это в виду, мы можем воспользоваться функциями отношений Eloquent:

1
2
3
4
5
//Get a user’s groups
$groups = User::find($user_id)->groups;
 
//Get all users in a group
$users = Group::find($group_id)->users;

Шаг 1 — Создание базы данных Instapics

Instapics

Продолжая наше веб-приложение Instapics , давайте начнем с создания базы данных нашего приложения. Для этого запишем нужные функции приложения:

  • Пользователи могут войти и зарегистрироваться для учетной записи
  • Пользователи могут следить за другими пользователями, чтобы увидеть фотографии, которые они загрузили
  • Пользователи могут загрузить свою фотографию и применить к ней фильтр
  • Пользователи могут комментировать и лайкать фотографии

Из этого мы можем вывести таблицы базы данных, которые нам понадобятся:

  • пользователи

    • id (один-к-одному с user_profiles.user_id, многие-ко-многим с самостоятельным использованием промежуточных таблиц отношений .follower_id и follow_id, один-ко-многим с photos.user_id и photo_comments.user_id)
    • Эл. адрес
    • пароль
    • создан в
    • updated_at
  • user_profiles

    • Я бы
    • user_id (один на один с users.id)
    • имя
    • Аватар
  • отношения

    • Я бы
    • follower_id (один на один с users.id)
    • follow_id (один на один с users.id)
    • создан в
    • updated_at
  • фотографии

    • id (один-ко-многим с photo_comments.user_id)
    • user_id (один на один с users.id)
    • место расположения
    • описание
    • создан в
    • updated_at
  • photo_comments

    • Я бы
    • user_id (один на один с users.id)
    • photo_id (один на один с photos.id)
    • сообщение
    • создан в
    • updated_at

Давайте продолжим и создадим эти таблицы. Для этого проекта я буду использовать MySQL ; не стесняйтесь копировать и вставлять эти команды.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
CREATE DATABASE `instapics`;
USE `instapics`;
 
CREATE TABLE `instapics`.`users` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `email` VARCHAR(100) NOT NULL,
  `password` VARCHAR(100) NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_email`(`email`)
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
 
CREATE TABLE `instapics`.`user_profiles` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `name` TEXT NOT NULL,
  `profile_photo` TEXT NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_user_id`(`user_id`),
  CONSTRAINT `FK_user_profiles_user_id` FOREIGN KEY `FK_user_profiles_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
 
CREATE TABLE `instapics`.`relationships` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `follower_id` INTEGER UNSIGNED NOT NULL,
  `followed_id` INTEGER UNSIGNED NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `Index_follower_id_followed_id`(`follower_id`, `followed_id`),
  CONSTRAINT `FK_relationships_follower_id` FOREIGN KEY `FK_relationships_follower_id` (`follower_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_relationships_followed_id` FOREIGN KEY `FK_relationships_followed_id` (`followed_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
 
CREATE TABLE `instapics`.`photos` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `location` TEXT NOT NULL,
  `description` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photos_user_id` FOREIGN KEY `FK_photos_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;
 
CREATE TABLE `instapics`.`photo_comments` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` INTEGER UNSIGNED NOT NULL,
  `photo_id` INTEGER UNSIGNED NOT NULL,
  `message` TEXT NOT NULL,
  `created_at` DATETIME NOT NULL,
  `updated_at` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_photo_comments_user_id` FOREIGN KEY `FK_photo_comments_user_id` (`user_id`)
    REFERENCES `users` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
  CONSTRAINT `FK_photo_comments_photo_id` FOREIGN KEY `FK_photo_comments_photo_id` (`photo_id`)
    REFERENCES `photos` (`id`)
    ON DELETE CASCADE
    ON UPDATE CASCADE
)
ENGINE = InnoDB
CHARACTER SET utf8 COLLATE utf8_general_ci;

В качестве альтернативы вы можете использовать миграции, но мы рассмотрим их в следующем уроке.

Шаг 2 — Настройка конфигурации базы данных Laravel

Прежде чем что-то делать с моделями Laravel, нам нужно настроить конфигурацию базы данных нашей установки Laravel. Откройте application / config / database.php , чтобы найти некоторые из этих настроек:

  • profile — при значении true все запросы SQL будут записываться в журналы Laravel. Оставьте это как true на данный момент.
  • fetch — тип возвращаемых данных из PDO. Значением по умолчанию является PDO::FETCH_CLASS и его следует оставить так.
  • default — это имя параметров подключения, используемых приложением. Имя относится к индексу в массиве $connections чуть ниже
  • соединения — ассоциативный массив возможных соединений для вашего приложения.

    • драйвер — тип сервера базы данных. Это может быть pgsql , sqlite , mysql или sqlsrv
    • host — имя хоста вашего сервера базы данных
    • база данных — имя базы данных
    • username — имя пользователя для использования на сервере базы данных
    • пароль — пароль для использования на сервере базы данных
    • charset — кодировка для использования на сервере базы данных
    • префикс — префикс таблицы в базе данных, если есть
  • redis — если вы планируете использовать библиотеку Redis Laravel, вы можете настроить информацию о сервере здесь.

Для целей этого урока мы будем использовать MySQL. Ваш файл database.php должен выглядеть примерно так (я удалил комментарии, но они должны быть в порядке):

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
return array(
    ‘profile’ => true,
    ‘fetch’ => PDO::FETCH_CLASS,
    ‘default’ => ‘mysql’,
    ‘connections’ => array(
        ‘mysql’ => array(
            ‘driver’ => ‘mysql’,
            ‘host’ => ‘localhost’,
            ‘database’ => ‘instapics’,
            ‘username’ => ‘root’,
            ‘password’ => ‘(yourpassword)’,
            ‘charset’ => ‘utf8’,
            ‘prefix’ => »,
        ),
    ),
    ‘redis’ => array(
        ‘default’ => array(
            ‘host’ => ‘127.0.0.1’,
            ‘port’ => 6379,
            ‘database’ => 0
        ),
    )
);

Шаг 3 — Создание вашей первой модели Laravel

Начните с создания модели Laravel внутри папки application / models . Создайте user.php внутри и добавьте следующий код:

1
2
3
class User extends Eloquent {
 
}

Теперь, основываясь на нашем обзоре отношений User , нам нужно кодировать методы отношений для всех них:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class User extends Eloquent {
     
    //setting $timestamp to true so Eloquent
    //will automatically set the created_at
    //and updated_at values
    public static $timestamps = true;
     
    public function user_profile()
    {
        return $this->has_one(‘User_Profile’);
    }
     
    public function followers()
    {
        return $this->has_many_and_belongs_to(‘User’, ‘relationships’, ‘followed_id’, ‘follower_id’);
    }
     
    public function following()
    {
        return $this->has_many_and_belongs_to(‘User’, ‘relationships’, ‘follower_id’, ‘followed_id’);
    }
     
    public function photos()
    {
        return $this->has_many(‘Photo’);
    }
     
    public function photo_comment()
    {
        return $this->has_many(‘Photo_Comment’);
    }
}

Примечательно, что здесь мы используем некоторые расширенные функциональные возможности «многие ко многим» из-за структуры таблицы нашей модели последователей (то есть таблица users ссылается на таблицу relationships которая снова ссылается на таблицу users ). Функция has_many_and_belongs_to имеет следующую сигнатуру метода:

01
02
03
04
05
06
07
08
09
10
/**
 * Get the query for a many-to-many relationship.
 *
 * @param string $model
 * @param string $table
 * @param string $foreign
 * @param string $other
 * @return Relationship
*/
public function has_many_and_belongs_to($model, $table = null, $foreign = null, $other = null)

Это фактически позволяет нам создать модель, которая имеет отношение «многие ко многим» с самим собой (т.е. пользователи следуют за другими пользователями). Мы используем followers и following имена методов в модели User чтобы мы могли получить подписчиков пользователя или всех пользователей, за которыми следует один пользователь, соответственно.

Следуя модели User , создайте другие модели. Когда вы закончите, вы должны иметь:

  • приложение / модели / photo.php
  • приложение / модели / photo_comment.php
  • приложение / модели / relationship.php
  • приложение / модели / user.php
  • приложение / модели / user_profile.php

Эти файлы будут в Git-репозитории учебника, поэтому, если вы предпочитаете загружать их, вы можете найти их здесь: https://github.com/nikkobautista/laravel-tutorial

Шаг 4 — Создание пользовательских функций для Instapics

Давайте начнем использовать наши модели с создания некоторых пользовательских функций, которые нам понадобятся в приложении. Сначала: регистрация пользователя. Из предыдущего урока мы уже создали форму регистрации / входа на главной странице. Сейчас он ничего не делает, но давайте подключим его к контроллеру User , authenticate действие. Создайте application / controllers / user.php со следующим кодом:

1
2
3
4
5
6
7
class User_Controller extends Base_Controller
{
    public function action_authenticate()
    {
         
    }
}

Откройте приложение / views / home / index.blade.php и найдите форму входа. Обновите форму в строке 18 для отправки в метод action_authenticate() :

1
<form class=»well» method=»POST» action=»user/authenticate»>

Возвращаясь к User_Controller , давайте User_Controller некоторый код в action_authenticate() :

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class User_Controller extends Base_Controller
{
    public function action_authenticate()
    {
        $email = Input::get(’email’);
        $password = Input::get(‘password’);
        $new_user = Input::get(‘new_user’, ‘off’);
         
        if( $new_user == ‘on’ ) {
            try {
                $user = new User();
                $user->email = $email;
                $user->password = Hash::make($password);
                $user->save();
                Auth::login($user);
             
                return Redirect::to(‘dashboard/index’);
            } catch( Exception $e ) {
                echo «Faield to create new user!»;
            }
        } else {
            $credentials = array(
                ‘username’ => $email,
                ‘password’ => $password
            );
            if( Auth::attempt($credentials)) {
                return Redirect::to(‘dashboard/index’);
            } else {
                echo «Failed to login!»;
            }
        }
    }
}

Давайте разберемся с тем, что мы сделали здесь:

  • Мы используем библиотеку Input чтобы получить входные данные из отправленной формы
  • Если флаг $new_user был $new_user , мы создаем нового User , используя библиотеку Hash для генерации зашифрованного пароля.
  • Войдите в систему нового User с библиотекой Auth
  • Если флаг $new_user не установлен, мы создаем массив $credentials и используем его с библиотекой Auth .
  • Если Auth::attempt имеет значение true, это означает, что учетные данные были правильными, и мы вошли в систему
  • Иначе, это означает, что учетные данные были неправильными.
  • В обоих сценариях перенаправьте на контроллер Dashboard , index действие при успешном завершении и выведите сообщение об ошибке, если нет.

Входная библиотека

Основная функция библиотеки Input — включить извлечение данных формы. Например, в контроллере User мы использовали Input::get('email'); чтобы получить значение электронной почты из формы. Важно отметить, что метод get используется для всех типов запросов, а не только для массива $ _GET .

Вы можете прочитать больше о библиотеке ввода здесь: http://laravel.com/docs/input#input

Библиотека Auth

Laravel поставляется с собственным механизмом аутентификации, библиотекой Auth . Он может выполнять следующие функции в отношении аутентификации пользователя.

Создание хешированного пароля

Мы можем использовать библиотеку Hash следующим образом:

1
$password = Hash::make($plaintext_password);

Этот метод создает соленый и хешированный пароль для пользователя, используя ключ шифрования, который мы установили в файле конфигурации. Чтобы проверить правильность хэша, вы можете использовать:

1
2
3
if( Hash::check($plaintext_password, $hashed_password) == true ) {
    echo ‘Password is correct.’;
}

Вход в систему пользователя

Для этого мы используем метод attempt библиотеки Auth . Однако до этого мы создаем массив $credentials , который является ассоциативным массивом с индексами username и password :

1
2
3
4
5
6
7
8
9
$credentials = array(
    ‘username’ => ‘[email protected]’,
    ‘password’ => ‘yourpassword’
);
if( Auth::attempt($credentials) == true ) {
    echo ‘User is logged in’;
} else {
    echo ‘Credentials failed’;
}

Важно помнить, что, как только попытка «успешна», пользователь автоматически входит в систему.

Вход пользователя в систему

Иногда нам необходимо войти в систему пользователя, не используя метод attempt (например, при входе пользователя по ссылке внутри электронной почты или после регистрации). Мы можем сделать это с помощью метода Auth::login :

1
2
Auth::login($user);
Auth::login(42);

С другой стороны, у нас также есть метод Auth::logout для Auth::logout из системы:

1
Auth::logout();

Это завершит сеанс пользователя.

Получение данных авторизованного пользователя

Метод Auth::user позволяет нам получить зарегистрированный пользовательский объект, а также любую информацию, прикрепленную к нему:

1
2
$email = Auth::user()->email;
$created_at = Auth::user()->created_at;

Настройка библиотеки Auth

Библиотека Auth должна быть настроена перед использованием (хотя значения по умолчанию будут работать с большинством проектов, таких как этот). Переменные конфигурации:

  • Водитель — это может быть либо красноречивым, либо бегло . Разработчики могут писать свои собственные драйверы, расширяя класс Driver в laravel / auth / drivers .
  • username — это имя столбца того, что представляет «имя пользователя» вашего пользователя в таблице базы данных.
  • модель — при использовании Eloquent это класс модели, который использует библиотека Auth
  • таблица — при использовании драйвера аутентификации Fluent это определяет таблицу базы данных для пользователей в приложении

Наш проект, Instapics, использует значения по умолчанию в файле конфигурации auth.php , поэтому нам не нужно ничего менять в нем.

Возвращаясь к проекту, попробуйте проверить возможности входа / регистрации Instapics! Довольно изящно, а? Однако вы заметите, что у нас еще ничего нет в контроллере Dashboard , поэтому давайте поработаем над этим дальше.

Шаг 5 — Создайте панель инструментов Instapics

Первое, что нам нужно сделать, это создать контроллер Dashboard с действием index . Создайте файл application / controllers / dashboard.php и вставьте следующий код:

1
2
3
4
5
6
7
8
class Dashboard_Controller extends Base_Controller
{
    public function action_index()
    {
        $photos = Auth::user()->photos()->order_by(‘created_at’, ‘desc’)->order_by(‘id’, ‘desc’)->get();
        return View::make(‘dashboard.index’, array(‘photos’ => $photos));
    }
}

Теперь нам нужно создать страницу индекса Dashboard. Создайте приложение / views / dashboard / index.blade.php и добавьте следующее:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
@layout(‘layouts/main’)
 
@section(‘navigation’)
@parent
<li><a href=»user/logout»>Logout</a></li>
@endsection
 
@section(‘content’)
<div class=»row»>
    <div class=»span3″>
        <div class=»well sidebar-nav»>
            <ul class=»nav nav-list»>
                <li class=»nav-header»>Followers</li>
            </ul>
            <div style=»margin-left: 10px»>
                @forelse (Auth::user()->followers as $follower)
                    <div style=»float: left; width: 30px; margin: 0px 3px 3px 5px;»>
                        <img src=»http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($follower->email))) }}?s=25&d=retro» alt=»Follower» title=»{{ $follower->email }}» />
                    </div>
                @empty
                    <div>You have no followers.</div>
                @endforelse
                <div style=»clear: both»></div>
            </div>
             
            <ul class=»nav nav-list»>
                <li class=»nav-header»>Following</li>
            </ul>
            <div style=»margin-left: 10px»>
                @forelse (Auth::user()->following as $following)
                    <div style=»float: left; width: 30px; margin: 0px 3px 3px 5px;»>
                        <img src=»http://nettuts.s3.amazonaws.com/2069_laravel_2/http://gravatar.com/avatar/{{ md5(strtolower(trim($following->email))) }}?s=25&d=retro» alt=»Following» title=»{{ $following->email }}» />
                    </div>
                @empty
                    <div>You are not following anybody.</div>
                @endforelse
                <div style=»clear: both»></div>
            </div>
        </div>
    </div>
    <div class=»span9″>
        <h1>Your Photos</h1>
        @forelse ($photos as $photo)
        <div class=»well» style=»text-align: center»>
            <img src=»http://nettuts.s3.amazonaws.com/2069_laravel_2/{{ $photo->location }}» alt=»{{ $photo->description }}» title=»{{ $photo->description }}» />
            <p>{{ $photo->description }}</p>
        </div>
        @empty
        <div class=»alert alert-info»>
            <h4 class=»alert-heading»>Awww!</h4>
            <p>Seems like you don’t have any photos yet.
        </div>
        @endforelse
    </div>
</div>
@endsection

Обновите страницу панели инструментов, вы должны увидеть это:

Панель инструментов Instapics

Глядя немного голым? Добавьте это к контроллеру Dashboard и запустите, dashboard/insert_test_data в вашем браузере:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public function action_insert_test_data()
{
    $logged_in_user = Auth::user();
     
    for( $x = 0; $x < 10; $x++ ) {
        $email = rand().’@gmail.com’;
        $user = new User();
        $user->email = $email;
        $user->password = Hash::make($email);
        $user->save();
         
        $logged_in_user->followers()->attach($user->id);
        if( $x > 5 ) {
            $logged_in_user->following()->attach($user->id);
        }
    }
     
    $photos = array(
        array(
            ‘user_id’ => $logged_in_user->id,
            ‘location’ => ‘http://farm6.staticflickr.com/5044/5319042359_68fb1f91b4.jpg’,
            ‘description’ => ‘Dusty Memories, The Girl in the Black Beret (http://www.flickr.com/photos/cloudy-day/)’
        ),
        array(
            ‘user_id’ => $logged_in_user->id,
            ‘location’ => ‘http://farm3.staticflickr.com/2354/2180198946_a7889e3d5c.jpg’,
            ‘description’ => ‘Rascals, Tannenberg (http://www.flickr.com/photos/tannenberg/)’
        ),
        array(
            ‘user_id’ => $logged_in_user->id,
            ‘location’ => ‘http://farm7.staticflickr.com/6139/5922361568_85628771cd.jpg’,
            ‘description’ => ‘Sunset, Funset, Nikko Bautista (http://www.flickr.com/photos/nikkobautista/)’
        )
    );
    $logged_in_user->photos()->save($photos);
}

Когда вы обновите страницу, вы увидите, как она выглядит со вставленными образцами данных:

Instapics Dashboard w Пример данных

Вывод

Во второй части нашей серии Laravel мы узнали:

  • Некоторая справка о том, что такое «Модели»
  • Что такое Eloquent ORM
  • Как настроить конфигурацию базы данных Laravel
  • Как создать свою первую модель Laravel
  • Основные функции библиотек Auth и Input
  • Использование Eloquent ORM в представлении

Eloquent действительно является отличной реализацией ORM — она ​​быстрая и имеет множество функций, которые делают взаимодействие с базой данных в любом приложении максимально простым.

Далее в наших веб-приложениях из серии Scratch with Laravel мы узнаем больше об использовании фильтров Laravel, библиотеке проверки Laravel и о том, как работать с файлами в Laravel!

Что вы думаете о Eloquent ORM от Laravel? Это то, что вы считаете полезным? Дай мне знать в комментариях! И, если вы являетесь участником Tuts + Premium , следите за обновлениями нашего предстоящего курса Laravel Essentials!

46
Share: