Initial Drupal 11 with DDEV setup

web/core/modules/user/src/Entity/EntityPermissionsRouteProvider.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Drupal\user\Entity;
+
+use Drupal\Core\Entity\EntityHandlerInterface;
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\Routing\EntityRouteProviderInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * Provides routes for the entity permissions form.
+ *
+ * Use this class as a route provider for an entity type such as Vocabulary. It
+ * will provide routes for the entity permissions form.
+ */
+class EntityPermissionsRouteProvider implements EntityRouteProviderInterface, EntityHandlerInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Constructs a new EntityPermissionsRouteProvider.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function createInstance(ContainerInterface $container, EntityTypeInterface $entity_type) {
+    return new static(
+      $container->get('entity_type.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRoutes(EntityTypeInterface $entity_type) {
+    $collection = new RouteCollection();
+
+    $entity_type_id = $entity_type->id();
+
+    if ($entity_permissions_route = $this->getEntityPermissionsRoute($entity_type)) {
+      $collection->add("entity.$entity_type_id.entity_permissions_form", $entity_permissions_route);
+    }
+
+    return $collection;
+  }
+
+  /**
+   * Gets the entity permissions route.
+   *
+   * Built only for entity types that are bundles of other entity types and
+   * define the 'entity-permissions-form' link template.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
+   *   The entity type.
+   *
+   * @return \Symfony\Component\Routing\Route|null
+   *   The generated route, if available.
+   */
+  protected function getEntityPermissionsRoute(EntityTypeInterface $entity_type): ?Route {
+    if (!$entity_type->hasLinkTemplate('entity-permissions-form')) {
+      return NULL;
+    }
+
+    if (!$bundle_of_id = $entity_type->getBundleOf()) {
+      return NULL;
+    }
+
+    $entity_type_id = $entity_type->id();
+    $route = new Route(
+      $entity_type->getLinkTemplate('entity-permissions-form'),
+      [
+        '_title' => 'Manage permissions',
+        '_form' => 'Drupal\user\Form\EntityPermissionsForm',
+        'entity_type_id' => $bundle_of_id,
+        'bundle_entity_type' => $entity_type_id,
+      ],
+      [
+        '_permission' => 'administer permissions',
+      ],
+      [
+        // Indicate that Drupal\Core\Entity\Enhancer\EntityBundleRouteEnhancer
+        // should set the bundle parameter.
+        '_field_ui' => TRUE,
+        'parameters' => [
+          $entity_type_id => [
+            'type' => "entity:$entity_type_id",
+            'with_config_overrides' => TRUE,
+          ],
+        ],
+        '_admin_route' => TRUE,
+      ]
+    );
+
+    return $route;
+  }
+
+}

web/core/modules/user/src/Entity/EntityPermissionsRouteProviderWithCheck.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\user\Entity;
+
+use Drupal\Core\Entity\EntityTypeInterface;
+use Symfony\Component\Routing\Route;
+
+/**
+ * Provides routes for the entity permissions form with a custom access check.
+ *
+ * Use this class or EntityPermissionsRouteProvider as a route provider for an
+ * entity type such as BlockContentType. Either one will provide routes for the
+ * entity permissions form. This class provides a custom access check: it denies
+ * access if there are no entity-specific permissions. If you know that each
+ * entity has permissions, or if the check is too expensive, then use
+ * EntityPermissionsRouteProvider instead of this class.
+ *
+ * @deprecated in drupal:11.1.0 and is removed from drupal:12.0.0. Use
+ * EntityPermissionsRouteProvider instead.
+ * @see https://www.drupal.org/node/3384745
+ */
+class EntityPermissionsRouteProviderWithCheck extends EntityPermissionsRouteProvider {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getEntityPermissionsRoute(EntityTypeInterface $entity_type): ?Route {
+    @trigger_error(__CLASS__ . ' is deprecated in drupal:11.1.0 and is removed from drupal:12.0.0. Use EntityPermissionsRouteProvider instead. See https://www.drupal.org/node/3384745', E_USER_DEPRECATED);
+    $route = parent::getEntityPermissionsRoute($entity_type);
+    if ($route) {
+      $route->setRequirement('_custom_access', '\Drupal\user\Form\EntityPermissionsForm::access');
+    }
+    return $route;
+  }
+
+}

web/core/modules/user/src/Entity/Role.php

@@ -0,0 +1,292 @@
+<?php
+
+namespace Drupal\user\Entity;
+
+use Drupal\Core\Config\Action\Attribute\ActionMethod;
+use Drupal\Core\Config\Entity\ConfigEntityBase;
+use Drupal\Core\Entity\Attribute\ConfigEntityType;
+use Drupal\Core\Entity\EntityDeleteForm;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\user\RoleAccessControlHandler;
+use Drupal\user\RoleForm;
+use Drupal\user\RoleInterface;
+use Drupal\user\RoleListBuilder;
+use Drupal\user\RoleStorage;
+
+/**
+ * Defines the user role entity class.
+ */
+#[ConfigEntityType(
+  id: 'user_role',
+  label: new TranslatableMarkup('Role'),
+  label_collection: new TranslatableMarkup('Roles'),
+  label_singular: new TranslatableMarkup('role'),
+  label_plural: new TranslatableMarkup('roles'),
+  config_prefix: 'role',
+  static_cache: TRUE,
+  entity_keys: [
+    'id' => 'id',
+    'weight' => 'weight',
+    'label' => 'label',
+  ],
+  handlers: [
+    'storage' => RoleStorage::class,
+    'access' => RoleAccessControlHandler::class,
+    'list_builder' => RoleListBuilder::class,
+    'form' => [
+      'default' => RoleForm::class,
+      'delete' => EntityDeleteForm::class,
+    ],
+  ],
+  links: [
+    'delete-form' => '/admin/people/roles/manage/{user_role}/delete',
+    'edit-form' => '/admin/people/roles/manage/{user_role}',
+    'edit-permissions-form' => '/admin/people/permissions/{user_role}',
+    'collection' => '/admin/people/roles',
+  ],
+  admin_permission: 'administer permissions',
+  label_count: [
+    'singular' => '@count role',
+    'plural' => '@count roles',
+  ],
+  config_export: [
+    'id',
+    'label',
+    'weight',
+    'is_admin',
+    'permissions',
+  ],
+)]
+class Role extends ConfigEntityBase implements RoleInterface {
+
+  /**
+   * The machine name of this role.
+   *
+   * @var string
+   */
+  protected $id;
+
+  /**
+   * The human-readable label of this role.
+   *
+   * @var string
+   */
+  protected $label;
+
+  /**
+   * The weight of this role in administrative listings.
+   *
+   * @var int
+   */
+  protected $weight;
+
+  /**
+   * The permissions belonging to this role.
+   *
+   * @var array
+   */
+  protected $permissions = [];
+
+  /**
+   * An indicator whether the role has all permissions.
+   *
+   * @var bool
+   */
+  protected $is_admin = FALSE;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPermissions() {
+    if ($this->isAdmin()) {
+      return [];
+    }
+    return $this->permissions;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getWeight() {
+    return $this->get('weight');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setWeight($weight) {
+    $this->set('weight', $weight);
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasPermission($permission) {
+    if ($this->isAdmin()) {
+      return TRUE;
+    }
+    return in_array($permission, $this->permissions);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  #[ActionMethod(adminLabel: new TranslatableMarkup('Add permission to role'))]
+  public function grantPermission($permission) {
+    if ($this->isAdmin()) {
+      return $this;
+    }
+    if (!$this->hasPermission($permission)) {
+      $this->permissions[] = $permission;
+    }
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function revokePermission($permission) {
+    if ($this->isAdmin()) {
+      return $this;
+    }
+    $this->permissions = array_diff($this->permissions, [$permission]);
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isAdmin() {
+    return (bool) $this->is_admin;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setIsAdmin($is_admin) {
+    $this->is_admin = $is_admin;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function postLoad(EntityStorageInterface $storage, array &$entities) {
+    parent::postLoad($storage, $entities);
+    // Sort the queried roles by their weight.
+    // See \Drupal\Core\Config\Entity\ConfigEntityBase::sort().
+    uasort($entities, [static::class, 'sort']);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function preSave(EntityStorageInterface $storage) {
+    parent::preSave($storage);
+
+    if (!isset($this->weight)) {
+      // Set a role weight to make this new role last.
+      $this->weight = array_reduce($storage->loadMultiple(), function ($max, $role) {
+        return $max > $role->weight ? $max : $role->weight + 1;
+      }, 0);
+    }
+
+    if (!$this->isSyncing() && $this->hasTrustedData()) {
+      // Permissions are always ordered alphabetically to avoid conflicts in the
+      // exported configuration. If the save is not trusted then the
+      // configuration will be sorted by StorableConfigBase.
+      sort($this->permissions);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    parent::calculateDependencies();
+    // Load all permission definitions.
+    $permission_definitions = \Drupal::service('user.permissions')->getPermissions();
+    $valid_permissions = array_intersect($this->permissions, array_keys($permission_definitions));
+    $invalid_permissions = array_diff($this->permissions, $valid_permissions);
+    if (!empty($invalid_permissions)) {
+      \Drupal::logger('user')->error('Non-existent permission(s) assigned to role "@label" (@id) were removed. Invalid permission(s): @permissions.', [
+        '@label' => $this->label(),
+        '@id' => $this->id(),
+        '@permissions' => implode(', ', $invalid_permissions),
+      ]);
+      $this->permissions = $valid_permissions;
+    }
+    foreach ($valid_permissions as $permission) {
+      // Depend on the module that is providing this permission.
+      $this->addDependency('module', $permission_definitions[$permission]['provider']);
+      // Depend on any other dependencies defined by permissions granted to
+      // this role.
+      if (!empty($permission_definitions[$permission]['dependencies'])) {
+        $this->addDependencies($permission_definitions[$permission]['dependencies']);
+      }
+    }
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onDependencyRemoval(array $dependencies) {
+    $changed = parent::onDependencyRemoval($dependencies);
+    // Load all permission definitions.
+    $permission_definitions = \Drupal::service('user.permissions')->getPermissions();
+
+    // Convert config and content entity dependencies to a list of names to make
+    // it easier to check.
+    foreach (['content', 'config'] as $type) {
+      $dependencies[$type] = array_keys($dependencies[$type]);
+    }
+
+    // Remove any permissions from the role that are dependent on anything being
+    // deleted or uninstalled.
+    foreach ($this->permissions as $key => $permission) {
+      if (!isset($permission_definitions[$permission])) {
+        // If the permission is not defined then there's nothing we can do.
+        continue;
+      }
+
+      if (in_array($permission_definitions[$permission]['provider'], $dependencies['module'], TRUE)) {
+        unset($this->permissions[$key]);
+        $changed = TRUE;
+        // Process the next permission.
+        continue;
+      }
+
+      if (isset($permission_definitions[$permission]['dependencies'])) {
+        foreach ($permission_definitions[$permission]['dependencies'] as $type => $list) {
+          if (array_intersect($list, $dependencies[$type])) {
+            unset($this->permissions[$key]);
+            $changed = TRUE;
+            // Process the next permission.
+            continue 2;
+          }
+        }
+      }
+    }
+
+    return $changed;
+  }
+
+  /**
+   * Returns all valid permissions.
+   *
+   * @return string[]
+   *   All possible valid permissions.
+   *
+   * @see \Drupal\user\PermissionHandler::getPermissions()
+   *
+   * @internal
+   * @todo Revisit in https://www.drupal.org/node/3446364
+   */
+  public static function getAllValidPermissions(): array {
+    return array_keys(\Drupal::service('user.permissions')->getPermissions());
+  }
+
+}

web/core/modules/user/src/Entity/User.php

@@ -0,0 +1,609 @@
+<?php
+
+namespace Drupal\user\Entity;
+
+use Drupal\Core\Entity\Attribute\ContentEntityType;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\Core\Entity\ContentEntityBase;
+use Drupal\Core\Entity\EntityChangedTrait;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Field\BaseFieldDefinition;
+use Drupal\Core\Flood\PrefixFloodInterface;
+use Drupal\Core\Language\LanguageInterface;
+use Drupal\user\Form\UserCancelForm;
+use Drupal\user\ProfileForm;
+use Drupal\user\ProfileTranslationHandler;
+use Drupal\user\RegisterForm;
+use Drupal\user\RoleInterface;
+use Drupal\user\StatusItem;
+use Drupal\user\TimeZoneItem;
+use Drupal\user\UserAccessControlHandler;
+use Drupal\user\UserInterface;
+use Drupal\user\UserListBuilder;
+use Drupal\user\UserStorage;
+use Drupal\user\UserStorageSchema;
+use Drupal\user\UserViewsData;
+
+/**
+ * Defines the user entity class.
+ *
+ * The base table name here is plural, despite Drupal table naming standards,
+ * because "user" is a reserved word in many databases.
+ */
+#[ContentEntityType(
+  id: 'user',
+  label: new TranslatableMarkup('User'),
+  label_collection: new TranslatableMarkup('Users'),
+  label_singular: new TranslatableMarkup('user'),
+  label_plural: new TranslatableMarkup('users'),
+  entity_keys: [
+    'id' => 'uid',
+    'langcode' => 'langcode',
+    'uuid' => 'uuid',
+  ],
+  handlers: [
+    'storage' => UserStorage::class,
+    'storage_schema' => UserStorageSchema::class,
+    'access' => UserAccessControlHandler::class,
+    'list_builder' => UserListBuilder::class,
+    'views_data' => UserViewsData::class,
+    'route_provider' => [
+      'html' => UserRouteProvider::class,
+    ],
+    'form' => [
+      'default' => ProfileForm::class,
+      'cancel' => UserCancelForm::class,
+      'register' => RegisterForm::class,
+    ],
+    'translation' => ProfileTranslationHandler::class,
+  ],
+  links: [
+    'canonical' => '/user/{user}',
+    'edit-form' => '/user/{user}/edit',
+    'cancel-form' => '/user/{user}/cancel',
+    'collection' => '/admin/people',
+  ],
+  admin_permission: 'administer users',
+  base_table: 'users',
+  data_table: 'users_field_data',
+  translatable: TRUE,
+  label_count: [
+    'singular' => '@count user',
+    'plural' => '@count users',
+  ],
+  field_ui_base_route: 'entity.user.admin_form',
+  common_reference_target: TRUE,
+)]
+class User extends ContentEntityBase implements UserInterface {
+
+  use EntityChangedTrait;
+
+  /**
+   * Stores a reference for a reusable anonymous user entity.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected static $anonymousUser;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isNew() {
+    return !empty($this->enforceIsNew) || $this->id() === NULL;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function label() {
+    return $this->getDisplayName();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function preSave(EntityStorageInterface $storage) {
+    parent::preSave($storage);
+
+    // Make sure that the authenticated/anonymous roles are not persisted.
+    foreach ($this->get('roles') as $index => $item) {
+      if (in_array($item->target_id, [RoleInterface::ANONYMOUS_ID, RoleInterface::AUTHENTICATED_ID])) {
+        $this->get('roles')->offsetUnset($index);
+      }
+    }
+
+    // Store account cancellation information.
+    foreach (['user_cancel_method', 'user_cancel_notify'] as $key) {
+      if (isset($this->{$key})) {
+        \Drupal::service('user.data')->set('user', $this->id(), substr($key, 5), $this->{$key});
+      }
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function postSave(EntityStorageInterface $storage, $update = TRUE) {
+    parent::postSave($storage, $update);
+
+    if ($update) {
+      $session_manager = \Drupal::service('session_manager');
+      // If the password has been changed, delete all open sessions for the
+      // user and recreate the current one.
+      if ($this->pass->value != $this->getOriginal()->pass->value) {
+        $session_manager->delete($this->id());
+        if ($this->id() == \Drupal::currentUser()->id()) {
+          \Drupal::service('session')->migrate();
+        }
+
+        $flood_config = \Drupal::config('user.flood');
+        $flood_service = \Drupal::flood();
+        $identifier = $this->id();
+        if ($flood_config->get('uid_only')) {
+          // Clear flood events based on the uid only if configured.
+          $flood_service->clear('user.failed_login_user', $identifier);
+        }
+        elseif ($flood_service instanceof PrefixFloodInterface) {
+          $flood_service->clearByPrefix('user.failed_login_user', $identifier);
+        }
+
+      }
+
+      // If the user was blocked, delete the user's sessions to force a logout.
+      if ($this->getOriginal()->status->value != $this->status->value && $this->status->value == 0) {
+        $session_manager->delete($this->id());
+      }
+
+      // Send emails after we have the new user object.
+      if ($this->status->value != $this->getOriginal()->status->value) {
+        // The user's status is changing; conditionally send notification email.
+        $op = $this->status->value == 1 ? 'status_activated' : 'status_blocked';
+        _user_mail_notify($op, $this);
+      }
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function postDelete(EntityStorageInterface $storage, array $entities) {
+    parent::postDelete($storage, $entities);
+
+    $uids = array_keys($entities);
+    \Drupal::service('user.data')->delete(NULL, $uids);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRoles($exclude_locked_roles = FALSE) {
+    $roles = [];
+
+    // Users with an ID always have the authenticated user role.
+    if (!$exclude_locked_roles) {
+      if ($this->isAuthenticated()) {
+        $roles[] = RoleInterface::AUTHENTICATED_ID;
+      }
+      else {
+        $roles[] = RoleInterface::ANONYMOUS_ID;
+      }
+    }
+
+    foreach ($this->get('roles') as $role) {
+      if ($role->target_id) {
+        $roles[] = $role->target_id;
+      }
+    }
+
+    return $roles;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasRole($rid) {
+    return in_array($rid, $this->getRoles());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function addRole($rid) {
+
+    if (in_array($rid, [RoleInterface::AUTHENTICATED_ID, RoleInterface::ANONYMOUS_ID])) {
+      throw new \InvalidArgumentException('Anonymous or authenticated role ID must not be assigned manually.');
+    }
+
+    $roles = $this->getRoles(TRUE);
+    $roles[] = $rid;
+    $this->set('roles', array_unique($roles));
+
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function removeRole($rid) {
+    $this->set('roles', array_diff($this->getRoles(TRUE), [$rid]));
+
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasPermission(string $permission) {
+    return \Drupal::service('permission_checker')->hasPermission($permission, $this);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPassword() {
+    return $this->get('pass')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setPassword(#[\SensitiveParameter] $password) {
+    $this->get('pass')->value = $password;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getEmail() {
+    return $this->get('mail')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setEmail($mail) {
+    $this->get('mail')->value = $mail;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCreatedTime() {
+    return $this->get('created')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getLastAccessedTime() {
+    return $this->get('access')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setLastAccessTime($timestamp) {
+    $this->get('access')->value = $timestamp;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getLastLoginTime() {
+    return $this->get('login')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setLastLoginTime($timestamp) {
+    $this->get('login')->value = $timestamp;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isActive() {
+    return $this->get('status')->value == 1;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isBlocked() {
+    return $this->get('status')->value == 0;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function activate() {
+    if ($this->isAnonymous()) {
+      throw new \LogicException('The anonymous user account should remain blocked at all times.');
+    }
+    $this->get('status')->value = 1;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function block() {
+    $this->get('status')->value = 0;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getTimeZone() {
+    return $this->get('timezone')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPreferredLangcode($fallback_to_default = TRUE) {
+    $language_list = $this->languageManager()->getLanguages();
+    $preferred_langcode = $this->get('preferred_langcode')->value;
+    if (!empty($preferred_langcode) && isset($language_list[$preferred_langcode])) {
+      return $language_list[$preferred_langcode]->getId();
+    }
+    else {
+      return $fallback_to_default ? $this->languageManager()->getDefaultLanguage()->getId() : '';
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPreferredAdminLangcode($fallback_to_default = TRUE) {
+    $language_list = $this->languageManager()->getLanguages();
+    $preferred_langcode = $this->get('preferred_admin_langcode')->value;
+    if (!empty($preferred_langcode) && isset($language_list[$preferred_langcode])) {
+      return $language_list[$preferred_langcode]->getId();
+    }
+    else {
+      return $fallback_to_default ? $this->languageManager()->getDefaultLanguage()->getId() : '';
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getInitialEmail() {
+    return $this->get('init')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isAuthenticated() {
+    return $this->id() > 0;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isAnonymous() {
+    return $this->id() === 0 || $this->id() === '0';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getAccountName() {
+    return $this->get('name')->value ?: '';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDisplayName() {
+    $name = $this->getAccountName() ?: \Drupal::config('user.settings')->get('anonymous');
+    \Drupal::moduleHandler()->alter('user_format_name', $name, $this);
+    return $name;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUsername($username) {
+    $this->set('name', $username);
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setExistingPassword(#[\SensitiveParameter] $password) {
+    $this->get('pass')->existing = $password;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function checkExistingPassword(UserInterface $account_unchanged) {
+    $existing = $this->get('pass')->existing;
+    return $existing !== NULL && strlen($existing) > 0 &&
+      \Drupal::service('password')->check(trim($existing), $account_unchanged->getPassword());
+  }
+
+  /**
+   * Returns an anonymous user entity.
+   *
+   * @return \Drupal\user\UserInterface
+   *   An anonymous user entity.
+   */
+  public static function getAnonymousUser() {
+    if (!isset(static::$anonymousUser)) {
+
+      // @todo Use the entity factory once available, see
+      //   https://www.drupal.org/node/1867228.
+      $entity_type_manager = \Drupal::entityTypeManager();
+      $entity_type = $entity_type_manager->getDefinition('user');
+      $class = $entity_type->getClass();
+
+      static::$anonymousUser = new $class([
+        'uid' => [LanguageInterface::LANGCODE_DEFAULT => 0],
+        'name' => [LanguageInterface::LANGCODE_DEFAULT => ''],
+        // Explicitly set the langcode to ensure that field definitions do not
+        // need to be fetched to figure out a default.
+        'langcode' => [LanguageInterface::LANGCODE_DEFAULT => LanguageInterface::LANGCODE_NOT_SPECIFIED],
+      ], $entity_type->id());
+    }
+    return clone static::$anonymousUser;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
+    /** @var \Drupal\Core\Field\BaseFieldDefinition[] $fields */
+    $fields = parent::baseFieldDefinitions($entity_type);
+
+    $fields['uid']->setLabel(t('User ID'))
+      ->setDescription(t('The user ID.'));
+
+    $fields['uuid']->setDescription(t('The user UUID.'));
+
+    $fields['langcode']->setLabel(t('Language code'))
+      ->setDescription(t('The user language code.'))
+      ->setDisplayOptions('form', ['region' => 'hidden']);
+
+    $fields['preferred_langcode'] = BaseFieldDefinition::create('language')
+      ->setLabel(t('Preferred language code'))
+      ->setDescription(t("The user's preferred language code for receiving emails and viewing the site."))
+      // @todo Define this via an options provider once
+      //   https://www.drupal.org/node/2329937 is completed.
+      ->addPropertyConstraints('value', [
+        'AllowedValues' => ['callback' => __CLASS__ . '::getAllowedConfigurableLanguageCodes'],
+      ]);
+
+    $fields['preferred_admin_langcode'] = BaseFieldDefinition::create('language')
+      ->setLabel(t('Preferred admin language code'))
+      ->setDescription(t("The user's preferred language code for viewing administration pages."))
+      // @todo A default value of NULL is ignored, so we have to specify
+      //   an empty field item structure instead. Fix this in
+      //   https://www.drupal.org/node/2318605.
+      ->setDefaultValue([0 => ['value' => NULL]])
+      // @todo Define this via an options provider once
+      //   https://www.drupal.org/node/2329937 is completed.
+      ->addPropertyConstraints('value', [
+        'AllowedValues' => ['callback' => __CLASS__ . '::getAllowedConfigurableLanguageCodes'],
+      ]);
+
+    // The name should not vary per language. The username is the visual
+    // identifier for a user and needs to be consistent in all languages.
+    $fields['name'] = BaseFieldDefinition::create('string')
+      ->setLabel(t('Name'))
+      ->setDescription(t('The name of this user.'))
+      ->setRequired(TRUE)
+      ->setConstraints([
+        // No Length constraint here because the UserName constraint also covers
+        // that.
+        'UserName' => [],
+        'UserNameUnique' => [],
+      ]);
+    $fields['name']->getItemDefinition()->setClass('\Drupal\user\UserNameItem');
+
+    $fields['pass'] = BaseFieldDefinition::create('password')
+      ->setLabel(t('Password'))
+      ->setDescription(t('The password of this user (hashed).'))
+      ->addConstraint('ProtectedUserField');
+
+    $fields['mail'] = BaseFieldDefinition::create('email')
+      ->setLabel(t('Email'))
+      ->setDescription(t('The email of this user.'))
+      ->setDefaultValue('')
+      ->addConstraint('UserMailUnique')
+      ->addConstraint('UserMailRequired')
+      ->addConstraint('ProtectedUserField');
+
+    $fields['timezone'] = BaseFieldDefinition::create('string')
+      ->setLabel(t('Timezone'))
+      ->setDescription(t('The timezone of this user.'))
+      ->setSetting('max_length', 32)
+      // @todo Define this via an options provider once
+      //   https://www.drupal.org/node/2329937 is completed.
+      ->addPropertyConstraints('value', [
+        'AllowedValues' => ['callback' => __CLASS__ . '::getAllowedTimezones'],
+      ]);
+    $fields['timezone']->getItemDefinition()->setClass(TimeZoneItem::class);
+
+    $fields['status'] = BaseFieldDefinition::create('boolean')
+      ->setLabel(t('User status'))
+      ->setDescription(t('Whether the user is active or blocked.'))
+      ->setDefaultValue(FALSE);
+    $fields['status']->getItemDefinition()->setClass(StatusItem::class);
+
+    $fields['created'] = BaseFieldDefinition::create('created')
+      ->setLabel(t('Created'))
+      ->setDescription(t('The time that the user was created.'));
+
+    $fields['changed'] = BaseFieldDefinition::create('changed')
+      ->setLabel(t('Changed'))
+      ->setDescription(t('The time that the user was last edited.'))
+      ->setTranslatable(TRUE);
+
+    $fields['access'] = BaseFieldDefinition::create('timestamp')
+      ->setLabel(t('Last access'))
+      ->setDescription(t('The time that the user last accessed the site.'))
+      ->setDefaultValue(0);
+
+    $fields['login'] = BaseFieldDefinition::create('timestamp')
+      ->setLabel(t('Last login'))
+      ->setDescription(t('The time that the user last logged in.'))
+      ->setDefaultValue(0);
+
+    $fields['init'] = BaseFieldDefinition::create('email')
+      ->setLabel(t('Initial email'))
+      ->setDescription(t('The email address used for initial account creation.'))
+      ->setDefaultValue('');
+
+    $fields['roles'] = BaseFieldDefinition::create('entity_reference')
+      ->setLabel(t('Roles'))
+      ->setCardinality(BaseFieldDefinition::CARDINALITY_UNLIMITED)
+      ->setDescription(t('The roles the user has.'))
+      ->setSetting('target_type', 'user_role');
+
+    return $fields;
+  }
+
+  /**
+   * Returns the role storage object.
+   *
+   * @return \Drupal\user\RoleStorageInterface
+   *   The role storage object.
+   */
+  protected function getRoleStorage() {
+    return \Drupal::entityTypeManager()->getStorage('user_role');
+  }
+
+  /**
+   * Defines allowed timezones for the field's AllowedValues constraint.
+   *
+   * @return string[]
+   *   The allowed values.
+   */
+  public static function getAllowedTimezones() {
+    return \DateTimeZone::listIdentifiers();
+  }
+
+  /**
+   * Defines allowed configurable language codes for AllowedValues constraints.
+   *
+   * @return string[]
+   *   The allowed values.
+   */
+  public static function getAllowedConfigurableLanguageCodes() {
+    return array_keys(\Drupal::languageManager()->getLanguages(LanguageInterface::STATE_CONFIGURABLE));
+  }
+
+}

web/core/modules/user/src/Entity/UserRouteProvider.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Drupal\user\Entity;
+
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\Core\Entity\Routing\EntityRouteProviderInterface;
+use Symfony\Component\Routing\Route;
+use Symfony\Component\Routing\RouteCollection;
+
+/**
+ * Provides routes for the user entity.
+ */
+class UserRouteProvider implements EntityRouteProviderInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRoutes(EntityTypeInterface $entity_type) {
+    $route_collection = new RouteCollection();
+    $route = (new Route('/user/{user}'))
+      ->setDefaults([
+        '_entity_view' => 'user.full',
+        '_title_callback' => 'Drupal\user\Controller\UserController::userTitle',
+      ])
+      ->setRequirement('user', '\d+')
+      ->setRequirement('_entity_access', 'user.view');
+    $route_collection->add('entity.user.canonical', $route);
+
+    $route = (new Route('/user/{user}/edit'))
+      ->setDefaults([
+        '_entity_form' => 'user.default',
+        '_title_callback' => 'Drupal\user\Controller\UserController::userTitle',
+      ])
+      ->setOption('_admin_route', TRUE)
+      ->setRequirement('user', '\d+')
+      ->setRequirement('_entity_access', 'user.update');
+    $route_collection->add('entity.user.edit_form', $route);
+
+    $route = (new Route('/user/{user}/cancel'))
+      ->setDefaults([
+        '_title' => 'Cancel account',
+        '_entity_form' => 'user.cancel',
+      ])
+      ->setOption('_admin_route', TRUE)
+      ->setRequirement('user', '\d+')
+      ->setRequirement('_entity_access', 'user.delete');
+    $route_collection->add('entity.user.cancel_form', $route);
+
+    return $route_collection;
+  }
+
+}