mirror of
https://github.com/yiisoft/yii2.git
synced 2025-11-02 21:41:19 +08:00
Merge pull request #6662 from markmarco16/master
Update Guide ES [skip ci]
This commit is contained in:
Alexander Makarov
@ -1,7 +1,7 @@
|
||||
Almacenamiento de Datos en Caché
|
||||
================================
|
||||
|
||||
El almacenamiento de datos en caché trata del almacenamiento de alguna variable PHP en caché y recuperarla más tarde del mismo. También es la base de algunas de las características avanzadas de almacenamiento en caché, tales como [el almacenamiento en caché de consultas a la base de datos](#query-caching) y [el almacenamiento en caché de contenido](caching-content.md).
|
||||
El almacenamiento de datos en caché trata del almacenamiento de alguna variable PHP en caché y recuperarla más tarde del mismo. También es la base de algunas de las características avanzadas de almacenamiento en caché, tales como [el almacenamiento en caché de consultas a la base de datos](#query-caching) y [el almacenamiento en caché de contenido](caching-page.md).
|
||||
|
||||
El siguiente código muestra el típico patrón de uso para el almacenamiento en caché, donde la variable `$cache` se refiere al [componente caché](#cache-components):
|
||||
|
||||
@ -19,12 +19,13 @@ if ($data === false) {
|
||||
// $data está disponible aquí
|
||||
```
|
||||
|
||||
|
||||
## Componentes de Caché <a name="cache-components"></a>
|
||||
|
||||
El almacenamiento de datos en caché depende de los llamados *cache components* (componentes de caché) los cuales
|
||||
representan diferentes tipos de almacenamiento en caché, como por ejemplo en memoria, en archivos o en base de datos.
|
||||
|
||||
Los Componentes de Caché están normalmente registrados como componentes de la aplicación para que de esta forma puedan
|
||||
Los Componentes de Caché están normalmente registrados como [componentes de la aplicación](structure-application-components.md) para que de esta forma puedan
|
||||
ser configurados y accesibles globalmente. El siguiente código muestra cómo configurar el componente de aplicación
|
||||
`cache` para usar [memcached](http://memcached.org/) con dos servidores caché:
|
||||
|
||||
@ -64,6 +65,7 @@ el código que utiliza la caché. Por ejemplo, podrías modificar la configuraci
|
||||
|
||||
> Nota: Puedes registrar múltiples componentes de aplicación de caché. El componente llamado `cache` es usado por defecto por muchas clases caché-dependiente (ej. [[yii\web\UrlManager]]).
|
||||
|
||||
|
||||
### Almacenamientos de Caché Soportados <a name="supported-cache-storage"></a>
|
||||
|
||||
Yii proporciona varios componentes de caché que pueden almacenar datos en diferentes medios. A continuación
|
||||
@ -81,6 +83,7 @@ se muestra un listado con los componentes de caché disponibles:
|
||||
|
||||
> Nota: Puedes utilizar diferentes tipos de almacenamiento de caché en la misma aplicación. Una estrategia común es la de usar almacenamiento de caché en memoria para almacenar datos que son pequeños pero que son utilizados constantemente (ej. datos estadísticos), y utilizar el almacenamiento de caché en archivos o en base de datos para guardar datos que son grandes y utilizados con menor frecuencia (ej. contenido de página).
|
||||
|
||||
|
||||
## API de Caché <a name="cache-apis"></a>
|
||||
|
||||
Todos los componentes de almacenamiento de caché provienen de la misma clase "padre" [[yii\caching\Cache]] y por lo tanto soportan la siguiente API:
|
||||
@ -107,6 +110,7 @@ $cache['var1'] = $value1; // equivalente a: $cache->set('var1', $value1);
|
||||
$value2 = $cache['var2']; // equivalente a: $value2 = $cache->get('var2');
|
||||
```
|
||||
|
||||
|
||||
### Claves de Caché <a name="cache-keys"></a>
|
||||
|
||||
Cada elemento de datos almacenado en caché se identifica por una clave. Cuando se almacena un elemento de datos en la memoria caché, se debe especificar una clave. Más tarde, cuando se recupera el elemento de datos de la memoria caché, se debe proporcionar la clave correspondiente.
|
||||
@ -139,6 +143,7 @@ Cuando en un mismo almacenamiento en caché es utilizado por diferentes aplicaci
|
||||
|
||||
Para garantizar la interoperabilidad, deberían utilizarse sólo caracteres alfanuméricos.
|
||||
|
||||
|
||||
### Caducidad de Caché <a name="cache-expiration"></a>
|
||||
|
||||
Un elemento de datos almacenado en la memoria caché permanecerá en ella para siempre, a menos que sea removida de alguna manera debido a alguna directiva de caché (ej. el espacio de almacenamiento en caché está lleno y los datos más antiguos se eliminan). Para cambiar este comportamiento, podrías proporcionar un parámetro de caducidad al llamar [[yii\caching\Cache::set()|set()]] para guardar el elemento de datos. El parámetro nos indica por cuántos segundos el elemento se mantendrá válido en memoria caché. Cuando llames [[yii\caching\Cache::get()|get()]] para recuperar el elemento, si el tiempo de caducidad ha pasado, el método devolverá `false`, indicando que el elemento de datos no ha sido encontrado en la memoria caché. Por ejemplo,
|
||||
@ -155,9 +160,10 @@ if ($data === false) {
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### Dependencias de Caché <a name="cache-dependencies"></a>
|
||||
|
||||
Además de configurar el tiempo de expiración, los datos almacenados en caché pueden también ser invalidados conforme a algunos cambios en la caché de dependencias. Por ejemplo, [[yii\caching\FileDependency]] representa la dependencia del tiempo de modificación del archivo. Cuando esta dependencia cambia, significa que el archivo correspondiente ha cambiado. Como resultado, cualquier contenido anticuado que sea encontrado en la caché debería ser invalidado y la llamada a [[yii\caching\Cache::get()|get()]] debería devolver `null`.
|
||||
Además de configurar el tiempo de expiración, los datos almacenados en caché pueden también ser invalidados conforme a algunos cambios en la caché de dependencias. Por ejemplo, [[yii\caching\FileDependency]] representa la dependencia del tiempo de modificación del archivo. Cuando esta dependencia cambia, significa que el archivo correspondiente ha cambiado. Como resultado, cualquier contenido anticuado que sea encontrado en la caché debería ser invalidado y la llamada a [[yii\caching\Cache::get()|get()]] debería retornar falso.
|
||||
|
||||
Una dependencia es representada como una instancia de [[yii\caching\Dependency]] o su clase hija. Cuando llamas [[yii\caching\Cache::set()|set()]] para almacenar un elemento de datos en la caché, puedes pasar el objeto de dependencia asociado. Por ejemplo,
|
||||
|
||||
@ -206,6 +212,7 @@ El almacenamiento en caché de consultas se puede usar para [DAO](db-dao.md), as
|
||||
|
||||
> Nota: Algunos DBMS (ej. [MySQL](http://dev.mysql.com/doc/refman/5.1/en/query-cache.html)) también soporta el almacenamiento en caché desde el mismo servidor de la BD. Puedes optar por utilizar cualquiera de los mecanismos de memoria caché. El almacenamiento en caché de consultas previamente descrito tiene la ventaja que de que se puede especificar dependencias de caché de una forma flexible y son potencialmente mucho más eficientes.
|
||||
|
||||
|
||||
### Configuraciones <a name="query-caching-configs"></a>
|
||||
|
||||
Las consultas en caché tienen tres opciones configurables globales a través de [[yii\db\Connection]]:
|
||||
@ -279,6 +286,7 @@ $result = $db->cache(function ($db) {
|
||||
});
|
||||
```
|
||||
|
||||
|
||||
### Limitaciones <a name="query-caching-limitations"></a>
|
||||
|
||||
El almacenamiento en caché de consultas no funciona con los resultados de consulta que contienen controladores de recursos.
|
||||
|
||||
@ -97,19 +97,21 @@ $cache = new FileCache([
|
||||
|
||||
Por favor, presta atención a la documentación API para ver si una propiedad o el parámetro de un método soporta alias.
|
||||
|
||||
|
||||
Alias Predefinidos <a name="predefined-aliases"></a>
|
||||
------------------
|
||||
|
||||
Yii predefine un conjunto de alias para aliviar la necesidad de hacer referencia a rutas de archivo o URLs que son
|
||||
utilizadas regularmente. La siguiente es la lista de alias predefinidos por Yii:
|
||||
|
||||
- `@yii`: el directorio donde el archivo `BaseYii.php` se encuentra (también llamado el directorio de la libreria).
|
||||
- `@yii`: el directorio donde el archivo `BaseYii.php` se encuentra (también llamado el directorio del framework).
|
||||
- `@app`: la [[yii\base\Application::basePath|ruta base]] de la aplicación que se está ejecutando actualmente.
|
||||
- `@runtime`: la [[yii\base\Application::runtimePath|ruta de ejecución]] (carpeta `runtime) de la aplicación que se `
|
||||
está ejecutando actualmente.
|
||||
- `@vendor`: el [[yii\base\Application::vendorPath|directorio vendor de Composer].
|
||||
- `@runtime`: la [[yii\base\Application::runtimePath|ruta de ejecución]] de la aplicación en ejecución. Por defecto `@app/runtime`.
|
||||
- `@webroot`: el directorio raíz Web de la aplicación Web se está ejecutando actualmente.
|
||||
- `@web`: la URL base de la aplicación web se ejecuta actualmente.
|
||||
- `@web`: la URL base de la aplicación web se ejecuta actualmente. Tiene el mismo valor que [[yii\web\Request::baseUrl]].
|
||||
- `@vendor`: el [[yii\base\Application::vendorPath|directorio vendor de Composer]. Por defecto `@app/vendor`.
|
||||
- `@bower`, el directorio raíz que contiene [paquetes bower](http://bower.io/). Por defecto `@vendor/bower`.
|
||||
- `@npm`, el directorio raíz que contiene [paquetes npm](https://www.npmjs.org/). Por defecto `@vendor/npm`.
|
||||
|
||||
El alias `@yii` se define cuando incluyes el archivo `Yii.php` en tu [script de entrada](structure-entry-scripts.md),
|
||||
mientras que el resto de los alias están definidos en el constructor de la aplicación cuando se aplica la
|
||||
@ -119,7 +121,7 @@ mientras que el resto de los alias están definidos en el constructor de la apli
|
||||
Alias en Extensiones <a name="extension-aliases"></a>
|
||||
--------------------
|
||||
|
||||
Un alias se define automaticamente por cada [extension](structure-extensions.md) que ha sido instalada a través de Composer.
|
||||
Un alias se define automaticamente por cada [extensión](structure-extensions.md) que ha sido instalada a través de Composer.
|
||||
El alias es nombrado tras el `namespace` de raíz de la extensión instalada tal y como está declarada en su archivo `composer.json`,
|
||||
y representa el directorio raíz de la extensión. Por ejemplo, si instalas la extensión `yiisoft/yii2-jui`, tendrás
|
||||
automaticamente definido el alias `@yii/jui` durante la etapa [bootstrapping](runtime-bootstrapping.md) de la aplicación:
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
Autocarga de clases
|
||||
===================
|
||||
|
||||
Yii depende del [mecanismo de autocarga de clases](http://www.php.net/manual/en/language.oop5.autoload.php) para localizar
|
||||
Yii depende del [mecanismo de autocarga de clases](http://www.php.net/manual/es/language.oop5.autoload.php) para localizar
|
||||
e incluir los archivos de las clases requiridas. Proporciona un cargador de clases de alto rendimiento que cumple con el
|
||||
[estandard PSR-4](https://github.com/php-fig/fig-standards/blob/master/proposed/psr-4-autoloader/psr-4-autoloader.md).
|
||||
El cargador se instala cuando incluyes el archivo `Yii.php`.
|
||||
|
||||
@ -10,175 +10,14 @@ comportamiento puede responder a [eventos](concept-events.md) disparados por el
|
||||
o adaptar a la ejecución normal del código del componente.
|
||||
|
||||
|
||||
Usando comportamientos <a name="using-behaviors"></a>
|
||||
----------------------
|
||||
|
||||
Para poder utilizar un comportamiento, primero tienes que unirlo a un [[yii\base\Component|componente]]. Describiremos cómo
|
||||
puedes vincular un comportamiento en la próxima sub-sección.
|
||||
|
||||
Una vez que el comportamiento ha sido vinculado a un componente, su uso es sencillo.
|
||||
|
||||
Puedes usar a una variable *pública* o a una [propiedad](concept-properties.md) definida por un `getter` y/o un `setter`
|
||||
del comportamiento a través del componente con el que se ha vinculado, como por ejemplo,
|
||||
|
||||
```php
|
||||
// "prop1" es una propiedad definida en la clase comportamiento
|
||||
echo $component->prop1;
|
||||
$component->prop1 = $value;
|
||||
```
|
||||
|
||||
También puedes llamar métodos *públicos* del comportamiento de una forma similar,
|
||||
|
||||
```php
|
||||
// bar() es un método público definido dentro de la clase comportamiento
|
||||
$component->bar();
|
||||
```
|
||||
|
||||
Como puedes ver, aunque `$component` no tiene definida `prop1` y `bar()`, pueden ser usadas como si fueran parte
|
||||
definida del componente.
|
||||
|
||||
Si dos comportamientos definen la misma propiedad o método y ambos están vinculados con el mismo componente, el
|
||||
comportamiento que ha sido vinculado primero tendrá preferencia cuando se esté accediendo a la propiedad o método.
|
||||
|
||||
Un comportamiento puede estar asociado con un nombre cuando se une a un componente. Si este es el caso, es posible
|
||||
acceder al objeto de comportamiento mediante el nombre, como se muestra a continuación,
|
||||
|
||||
```php
|
||||
$behavior = $component->getBehavior('myBehavior');
|
||||
```
|
||||
|
||||
También puedes acceder a todos los comportamientos vinculados al componente:
|
||||
|
||||
```php
|
||||
$behaviors = $component->getBehaviors();
|
||||
```
|
||||
|
||||
|
||||
Vinculando Comportamientos <a name="attaching-behaviors"></a>
|
||||
Definiendo comportamientos <a name="defining-behaviors"></a>
|
||||
--------------------------
|
||||
|
||||
Puedes vincular un comportamiento a un [[yii\base\Component|componente]] ya sea estática o dinámicamente. La primera forma
|
||||
es la más comúnmente utilizada en la práctica.
|
||||
|
||||
Para unir un comportamiento estáticamente, reemplaza el método [[yii\base\Component::behaviors()|behaviors()]] de la
|
||||
clase componente que se está conectando. Por ejemplo,
|
||||
|
||||
```php
|
||||
namespace app\models;
|
||||
|
||||
use yii\db\ActiveRecord;
|
||||
use app\components\MyBehavior;
|
||||
|
||||
class User extends ActiveRecord
|
||||
{
|
||||
public function behaviors()
|
||||
{
|
||||
return [
|
||||
// comportamiento anónimo, sólo el nombre de la clase del comportamiento
|
||||
MyBehavior::className(),
|
||||
|
||||
// comportamiento nombrado, sólo el nombre de la clase del comportamiento
|
||||
'myBehavior2' => MyBehavior::className(),
|
||||
|
||||
// comportamiento anónimo, matriz de configuración
|
||||
[
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
],
|
||||
|
||||
// comportamiento nombrado, matriz de configuración
|
||||
'myBehavior4' => [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
]
|
||||
];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
El método [[yii\base\Component::behaviors()|behaviors()]] tiene que devolver la lista de los comportamientos
|
||||
[configuraciones](concept-configurations.md).
|
||||
Cada configuración de un comportamiento puede ser el nombre de la clase o una matriz de configuración.
|
||||
|
||||
Puedes asociciar un nombre a un comportamiento especificándolo en la clave de la matriz correspondiente a la configuración
|
||||
del comportamiento. En este caso, el comportamiento puede ser llamado un *comportamiento nombrado* (named behavior). En
|
||||
el ejemplo anterior, hay dos tipos de comportamientos nombrados: `myBehavior2` y `myBehavior4`. Si un comportamiento
|
||||
no está asociado con un nombre, se le llama *comportamiento anónimo* (anonymous behavior).
|
||||
|
||||
Para vincular un comportamiento dinámicamente, llama al método [[yii\base\Component::attachBehavior()]] desde el componente al
|
||||
que se le va a unir el comportamiento. Por ejemplo,
|
||||
|
||||
```php
|
||||
use app\components\MyBehavior;
|
||||
|
||||
// vincular un objeto comportamiento "behavior"
|
||||
$component->attachBehavior('myBehavior1', new MyBehavior);
|
||||
|
||||
// vincular una clase comportamiento
|
||||
$component->attachBehavior('myBehavior2', MyBehavior::className());
|
||||
|
||||
// asociar una matriz de configuración
|
||||
$component->attachBehavior('myBehavior3', [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
]);
|
||||
```
|
||||
|
||||
You may attach multiple behaviors at once by using the [[yii\base\Component::attachBehaviors()]] method.
|
||||
For example,
|
||||
|
||||
```php
|
||||
$component->attachBehaviors([
|
||||
'myBehavior1' => new MyBehavior, // a named behavior
|
||||
MyBehavior::className(), // an anonymous behavior
|
||||
]);
|
||||
```
|
||||
|
||||
También puedes asociar comportamientos a traves de [configuraciones](concept-configurations.md) compor el siguiente
|
||||
ejemplo. Para más detalles, por favor visita la sección [Configuraciones](concept-configurations.md#configuration-format).
|
||||
|
||||
```php
|
||||
[
|
||||
'as myBehavior2' => MyBehavior::className(),
|
||||
|
||||
'as myBehavior3' => [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
],
|
||||
]
|
||||
```
|
||||
|
||||
|
||||
Desasociar Comportamientos <a name="detaching-behaviors"></a>
|
||||
--------------------------
|
||||
|
||||
Para desasociar un comportamiento, puedes llamar el método [[yii\base\Component::detachBehavior()]] con el nombre con el
|
||||
que se le asoció:
|
||||
|
||||
```php
|
||||
$component->detachBehavior('myBehavior1');
|
||||
```
|
||||
|
||||
También puedes desvincular *todos* los comportamientos:
|
||||
|
||||
```php
|
||||
$component->detachBehaviors();
|
||||
```
|
||||
|
||||
|
||||
Definiendo Comportamientos <a name="defining-behaviors"></a>
|
||||
--------------------------
|
||||
|
||||
Para definir un comportamiento, crea una clase extendendiéndola de [[yii\base\Behavior]] o una de sus clases "hija". Por ejemplo,
|
||||
Para definir un comportamiento, se debe crear una clase que exiende [[yii\base\Behavior]], o se extiende una clase hija. Por ejemplo:
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
use yii\base\Model;
|
||||
use yii\base\Behavior;
|
||||
|
||||
class MyBehavior extends Behavior
|
||||
@ -203,20 +42,19 @@ class MyBehavior extends Behavior
|
||||
}
|
||||
}
|
||||
```
|
||||
El código anterior define la clase de comportamiento (behavior) app\components\MyBehavior`, con dos propiedades --
|
||||
`prop1` y `prop2`--y un método `foo()`. Tenga en cuenta que la propiedad `prop2`
|
||||
se define a través de la getter `getProp2()` y el setter `setProp2()`. Este caso es porque [[yii\base\Behavior]] extiende [[yii\base\Object]] y por lo tanto se apoya en la definición de [propiedades](concept-properties.md) via getters y setters.
|
||||
|
||||
El código anterior define la clase del comportamiento `app\components\MyBehavior` que provee dos propiedades `prop1` y
|
||||
`prop2`, y un método `foo()` al componente con el que está asociado.
|
||||
Debido a que esta clase es un comportamiento, cuando está unido a un componente, el componente también tienen la propiedad `prop1` y `prop2` y el método `foo()`.
|
||||
|
||||
The above code defines the behavior class `app\components\MyBehavior` which will provide two properties
|
||||
`prop1` and `prop2`, and one method `foo()` to the component it is attached to. Fíjese que la propiedad `prop2` esta
|
||||
definida a través del getter `getProp2()` y el setter `setProp2()`. Esto es debido a que [[yii\base\Object]] es una
|
||||
clase "ancestro" (o padre) de [[yii\base\Behavior]], la cual soporta la definición de [propiedades](concept-properties.md) por
|
||||
getters/setters.
|
||||
> Consejo: Dentro de un comportamiento, puede acceder al componente que el comportamiento está unido a través de la propiedad [[yii\base\Behavior::owner]].
|
||||
|
||||
En un comportamiento, puedes acceder al componente al que está vinculado a través de la propiedad [[yii\base\Behavior::owner]].
|
||||
|
||||
Si un omportamiento necesita responder a los eventos que han sido disparados desde el componente al qu están asociados,
|
||||
debería sobreescribir el método [[yii\base\Behavior::events()]]. Por ejemplo,
|
||||
Gestión de eventos de componentes
|
||||
---------------------------------
|
||||
|
||||
Si un comportamiento necesita responder a los acontecimientos desencadenados por el componente al que está unido, se debe reemplazar el método [[yii\base\Behavior::events()]]. Por ejemplo:
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
@ -242,18 +80,14 @@ class MyBehavior extends Behavior
|
||||
}
|
||||
```
|
||||
|
||||
El método [[yii\base\Behavior::events()|events()]] tiene que devolver un listado de eventos y sus correspondientes
|
||||
controladores (handlers). El código anterior declara el evento [[yii\db\ActiveRecord::EVENT_BEFORE_VALIDATE|EVENT_BEFORE_VALIDATE]]
|
||||
con su controlador `beforeValidate()`. Cuando se especifica un controlador de evento, pudes utilizar uno de los siguientes
|
||||
formatos:
|
||||
El método [[yii\base\Behavior::events()|events()]] debe devolver una lista de eventos y sus correspondientes controladores.
|
||||
El ejemplo anterior declara que el evento [[yii\db\ActiveRecord::EVENT_BEFORE_VALIDATE|EVENT_BEFORE_VALIDATE]] existe y esta exists y define su controlador, `beforeValidate()`. Al especificar un controlador de eventos, puede utilizar uno de los siguientes formatos:
|
||||
|
||||
* una cadena que se refiere al nombre de un método de la clase comportamiento, como el ejemplo anterior;
|
||||
* una matriz con un objeto o nombre de la clase, y el nombre de un método, por ejemplo, `[$object, 'nombreMétodo']`;
|
||||
* una función anónima.
|
||||
* una cadena que se refiere al nombre de un método de la clase del comportamiento, como el ejemplo anterior
|
||||
* un arreglo de objeto o nombre de clase, y un nombre de método como una cadena (sin paréntesis), ej., `[$object, 'methodName']`;
|
||||
* una función anónima
|
||||
|
||||
El formato de un controlador de eventos tendría que ser como se describe a continuación, donde `$event` se refiere al
|
||||
parámetro `evento`. Por favor, visita la sección [Eventos](concept-events.md) para obtener más información acerca de
|
||||
eventos.
|
||||
La firma de un controlador de eventos debe ser la siguiente, donde `$ event` refiere al parámetro de evento. Por favor, consulte la sección [Eventos](concept-events.md) para más detalles sobre los eventos.
|
||||
|
||||
```php
|
||||
function ($event) {
|
||||
@ -261,12 +95,164 @@ function ($event) {
|
||||
```
|
||||
|
||||
|
||||
Vinculando Comportamientos <a name="attaching-behaviors"></a>
|
||||
--------------------------
|
||||
|
||||
Puedes vincular un comportamiento a un [[yii\base\Component|componente]] ya sea estática o dinámicamente. La primera forma
|
||||
es la más comúnmente utilizada en la práctica.
|
||||
|
||||
Para unir un comportamiento estáticamente, reemplaza el método [[yii\base\Component::behaviors()|behaviors()]] dde la clase de componente a la que se une el comportamiento. El método [[yii\base\Component::behaviors()|behaviors()]] debe devolver una lista de comportamiento [configuraciones](concept-configurations.md).
|
||||
Cada configuración de comportamiento puede ser un nombre de clase de comportamiento o un arreglo de configuración:
|
||||
|
||||
```php
|
||||
namespace app\models;
|
||||
|
||||
use yii\db\ActiveRecord;
|
||||
use app\components\MyBehavior;
|
||||
|
||||
class User extends ActiveRecord
|
||||
{
|
||||
public function behaviors()
|
||||
{
|
||||
return [
|
||||
// anonymous behavior, behavior class name only
|
||||
MyBehavior::className(),
|
||||
|
||||
// named behavior, behavior class name only
|
||||
'myBehavior2' => MyBehavior::className(),
|
||||
|
||||
// anonymous behavior, configuration array
|
||||
[
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
],
|
||||
|
||||
// named behavior, configuration array
|
||||
'myBehavior4' => [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
]
|
||||
];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Puedes asociciar un nombre a un comportamiento especificándolo en la clave de la matriz correspondiente a la configuración
|
||||
del comportamiento. En este caso, el comportamiento puede ser llamado un *comportamiento nombrado* (named behavior). En
|
||||
el ejemplo anterior, hay dos tipos de comportamientos nombrados: `myBehavior2` y `myBehavior4`. Si un comportamiento
|
||||
no está asociado con un nombre, se le llama *comportamiento anónimo* (anonymous behavior).
|
||||
|
||||
Para vincular un comportamiento dinámicamente, llama al método [[yii\base\Component::attachBehavior()]] desde el componente al
|
||||
que se le va a unir el comportamiento:
|
||||
|
||||
```php
|
||||
use app\components\MyBehavior;
|
||||
|
||||
// vincular un objeto comportamiento "behavior"
|
||||
$component->attachBehavior('myBehavior1', new MyBehavior);
|
||||
|
||||
// vincular una clase comportamiento
|
||||
$component->attachBehavior('myBehavior2', MyBehavior::className());
|
||||
|
||||
// asociar una matriz de configuración
|
||||
$component->attachBehavior('myBehavior3', [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
]);
|
||||
```
|
||||
Puede vincular múltiples comportamientos a la vez mediante el uso del método [[yii\base\Component::attachBehaviors()]]. Por ejemplo,
|
||||
|
||||
```php
|
||||
$component->attachBehaviors([
|
||||
'myBehavior1' => new MyBehavior, // un comportamiento nombrado
|
||||
MyBehavior::className(), // un comportamiento anónimo
|
||||
]);
|
||||
```
|
||||
|
||||
También puedes asociar comportamientos a traves de [configuraciones](concept-configurations.md) como el siguiente:
|
||||
|
||||
```php
|
||||
[
|
||||
'as myBehavior2' => MyBehavior::className(),
|
||||
|
||||
'as myBehavior3' => [
|
||||
'class' => MyBehavior::className(),
|
||||
'prop1' => 'value1',
|
||||
'prop2' => 'value2',
|
||||
],
|
||||
]
|
||||
```
|
||||
|
||||
Para más detalles, por favor visita la sección [Configuraciones](concept-configurations.md#configuration-format).
|
||||
|
||||
|
||||
Usando comportamientos <a name="using-behaviors"></a>
|
||||
----------------------
|
||||
|
||||
Para poder utilizar un comportamiento, primero tienes que unirlo a un [[yii\base\Component|componente]] según las instrucciones anteriores. Una vez que un comportamiento ha sido vinculado a un componente, su uso es sencillo.
|
||||
|
||||
Puedes usar a una variable *pública* o a una [propiedad](concept-properties.md) definida por un `getter` y/o un `setter`
|
||||
del comportamiento a través del componente con el que se ha vinculado:
|
||||
|
||||
```php
|
||||
// "prop1" es una propiedad definida en la clase comportamiento
|
||||
echo $component->prop1;
|
||||
$component->prop1 = $value;
|
||||
```
|
||||
|
||||
También puedes llamar métodos *públicos* del comportamiento de una forma similar:
|
||||
|
||||
```php
|
||||
// foo() es un método público definido dentro de la clase comportamiento
|
||||
$component->foo();
|
||||
```
|
||||
|
||||
Como puedes ver, aunque `$component` no tiene definida `prop1` y `bar()`, que se pueden utilizar como si son parte
|
||||
de la definición de componentes debido al comportamiento vinculado.
|
||||
|
||||
Si dos comportamientos definen la misma propiedad o método y ambos están vinculados con el mismo componente, el
|
||||
comportamiento que ha sido vinculado *primero* tendrá preferencia cuando se esté accediendo a la propiedad o método.
|
||||
|
||||
Un comportamiento puede estar asociado con un nombre cuando se une a un componente. Si este es el caso, es posible
|
||||
acceder al objeto de comportamiento mediante el nombre, como se muestra a continuación,
|
||||
|
||||
```php
|
||||
$behavior = $component->getBehavior('myBehavior');
|
||||
```
|
||||
|
||||
También puedes acceder a todos los comportamientos vinculados al componente:
|
||||
|
||||
```php
|
||||
$behaviors = $component->getBehaviors();
|
||||
```
|
||||
|
||||
|
||||
Desasociar Comportamientos <a name="detaching-behaviors"></a>
|
||||
--------------------------
|
||||
|
||||
Para desasociar un comportamiento, puedes llamar el método [[yii\base\Component::detachBehavior()]] con el nombre con el
|
||||
que se le asoció:
|
||||
|
||||
```php
|
||||
$component->detachBehavior('myBehavior1');
|
||||
```
|
||||
|
||||
También puedes desvincular *todos* los comportamientos:
|
||||
|
||||
```php
|
||||
$component->detachBehaviors();
|
||||
```
|
||||
|
||||
|
||||
Utilizando `TimestampBehavior` <a name="using-timestamp-behavior"></a>
|
||||
-----------------------------
|
||||
|
||||
Para terminar, vamos a echar un vistazo a [[yii\behaviors\TimestampBehavior]] - un comportamiento que soporta de forma
|
||||
automática la actualización de atributos `timestamp` (sellos de tiempo) de un [[yii\db\ActiveRecord|Registro Activo]]
|
||||
(Active Record) cuando éste está siendo guardado.
|
||||
Para terminar, vamos a echar un vistazo a [[yii\behaviors\TimestampBehavior]]. Este comportamiento soporta de forma
|
||||
automática la actualización de atributos timestamp de un modelo [[yii\db\ActiveRecord|Registro Activo]]
|
||||
(Active Record) en cualquier momento donde se guarda el modelo (ej., en la inserción o actualización).
|
||||
|
||||
Primero, vincula este comportamiento a la clase [[yii\db\ActiveRecord|Active Record]] que desees utilizar.
|
||||
|
||||
@ -300,7 +286,7 @@ La configuración del comportamiento anterior especifica que
|
||||
* cuando el registro está siendo insertado, el comportamiento debe asignar el sello de tiempo actual a los atributos
|
||||
`created_at` y `updated_at`;
|
||||
* cuando el registro está siendo actualizado, el comportamiento debe asignar el sello de tiempo actual al atributo
|
||||
`updated_at.
|
||||
`updated_at`.
|
||||
|
||||
Ahora si tienes un objeto `User` e intentas guardarlo, descubrirás que sus campos `created_at` y `updated_at` están
|
||||
automáticamente actualizados con el sello de tiempo actual:
|
||||
@ -313,8 +299,7 @@ echo $user->created_at; // muestra el sello tiempo actual (timestamp)
|
||||
```
|
||||
|
||||
El comportamiento [[yii\behaviors\TimestampBehavior|TimestampBehavior]] también ofrece un método muy útil llamado
|
||||
[[yii\behaviors\TimestampBehavior::touch()|touch()]], que asigna el sello de tiempo actual a un atributo especificado y
|
||||
lo guarda automáticamente en la base de datos:
|
||||
[[yii\behaviors\TimestampBehavior::touch()|touch()]], que asigna el sello de tiempo actual a un atributo especificado y lo guarda automáticamente en la base de datos:
|
||||
|
||||
```php
|
||||
$user->touch('login_time');
|
||||
@ -326,13 +311,13 @@ Comparación con Traits <a name="comparison-with-traits"></a>
|
||||
|
||||
Mientras que los comportamientos son similares a [traits](http://www.php.net/traits) en cuanto que ambos "inyectan" sus
|
||||
métodos y propiedades a la clase primaria, son diferentes en muchos aspectos. Tal y como se describe abajo, los dos
|
||||
tienen sus ventajas y desventajas. Son much mejor descritos como complementos y no como reemplazos entre sí.
|
||||
tienen sus ventajas y desventajas. Son más como complementos el uno al otro en lugar de alternativas.
|
||||
|
||||
|
||||
### Las Ventajas de los Comportamientos <a name="pros-for-behaviors"></a>
|
||||
### Razones para utilizar comportamientos <a name="pros-for-behaviors"></a>
|
||||
|
||||
Las clases de comportamientos (Behaviors), como todas las clases, soportan herencias. Traits, por otro lado, pueden ser
|
||||
considerados como un copia-y-pega de PHP. Los Traits no soportan la herencia de clases.
|
||||
Las clases de comportamientos, como todas las clases, soportan herencias. Traits, por otro lado, pueden ser
|
||||
considerados como un copia-y-pega de PHP. Ellos no soportan la herencia de clases.
|
||||
|
||||
Los comportamientos pueden ser asociados y desasociados a un componente dinámicamente sin necesidad de que la clase del
|
||||
componente sea modificada. Para usar un trait, debes modificar la clase que la usa.
|
||||
@ -343,14 +328,13 @@ Los comportamientos pueden personalizar la ejecución de un componente al respon
|
||||
|
||||
Cuando hay un conflicto de nombre entre los diferentes comportamientos vinculados a un mismo componente, el conflicto es
|
||||
automáticamente resuelto respetando al que ha sido asociado primero.
|
||||
El conflicto de nombres en traits requiere que manualmente sean resueltos cambiando el nombre de las propiedades o métodos
|
||||
afectados.
|
||||
El conflicto de nombres en traits requiere que manualmente sean resueltos cambiando el nombre de las propiedades o métodos afectados.
|
||||
|
||||
|
||||
### Las Ventajas de los Traits <a name="pros-for-traits"></a>
|
||||
### Razones para utilizar los Traits <a name="pros-for-traits"></a>
|
||||
|
||||
Los Traits son mucho más eficientes que los comportamientos debido a que los últimos son objetos que consumen tiempo y
|
||||
memoria.
|
||||
|
||||
Los IDEs (Programas de desarrollo) trabajan mucho mejor con traits ya que forman parte del lenguaje PHP.
|
||||
Los IDEs (Programas de desarrollo) son más amigables con traits ya que son una construcción del lenguaje nativo.
|
||||
|
||||
|
||||
@ -29,9 +29,9 @@ Si tus componentes no necesitan estas dos características, deberías considerar
|
||||
|
||||
Cuando extiendes tu clase de [[yii\base\Component]] o [[yii\base\Object]], se recomienda que sigas las siguientes convenciones:
|
||||
|
||||
- Si sobrescribes el constructor, especifica un parámetro `$config` como el *último* parámetro del constructor, y después pasa este parámetro al constructor de la clase "padre".
|
||||
- Siempre llama al constructor del "padre" al *final* de su propio constructor.
|
||||
- Si sobrescribes el método [[yii\base\Object::init()]], asegúrate de que llamas a la implementación de la clase "padre" *al principio* de tu método `init`.
|
||||
- Si sobrescribes el constructor, especifica un parámetro `$config` como el *último* parámetro del constructor, y después pasa este parámetro al constructor padre.
|
||||
- Siempre llama al constructor padre al *final* de su propio constructor.
|
||||
- Si sobrescribes el método [[yii\base\Object::init()]], asegúrese de llamar la implementación padre de `init` * al principio * de su método` init`.
|
||||
|
||||
Por ejemplo:
|
||||
|
||||
|
||||
@ -70,7 +70,7 @@ Las configuraciones se utilizan en muchos lugares en Yii. Al comienzo de esta se
|
||||
|
||||
### Configuraciones de aplicación <a name="application-configurations"></a>
|
||||
|
||||
Configuración para una [aplicación](structure-applications.md) es probablemente una de las configuraciones más complejas. Esto se debe a que la clase [[yii\web\Application|application]] tiene un montón de propiedades y eventos configurables. Más importante aún, su propiedad [[yii\web\Application::components|components]] que puede recibir una gran variedad de configuraciones para crear componentes que se registran a través de la aplicación. Lo siguiente es un resumen del archivo de configuración de la aplicación para la [plantilla básica de la aplicación](start-installation.md).
|
||||
Configuración para una [aplicación](structure-applications.md) es probablemente una de las configuraciones más complejas. Esto se debe a que la clase [[yii\web\Application|aplicación]] tiene un montón de propiedades y eventos configurables. Más importante aún, su propiedad [[yii\web\Application::components|componentes]] que puede recibir una gran variedad de configuraciones para crear componentes que se registran a través de la aplicación. Lo siguiente es un resumen del archivo de configuración de la aplicación para la [plantilla básica de la aplicación](start-installation.md).
|
||||
|
||||
```php
|
||||
$config = [
|
||||
@ -137,7 +137,7 @@ Tenga en cuenta que debido a que el nombre de la clase ya está dado, la matriz
|
||||
|
||||
## Archivos de Configuración <a name="configuration-files"></a>
|
||||
|
||||
Cuando una configuración es muy compleja, una práctica común es almacenarla en uno o múltiples archivos PHP, conocidos como *Los archivos de configuración*. Un archivo de configuración devuelve un array de PHP que representa la configuración. Por ejemplo, es posible mantener una configuración de la aplicación en un archivo llamado `web.php`, como el siguiente,
|
||||
Cuando una configuración es muy compleja, una práctica común es almacenarla en uno o múltiples archivos PHP, conocidos como *archivos de configuración*. Un archivo de configuración devuelve un array de PHP que representa la configuración. Por ejemplo, es posible mantener una configuración de la aplicación en un archivo llamado `web.php`, como el siguiente,
|
||||
|
||||
```php
|
||||
return [
|
||||
@ -209,7 +209,8 @@ defined('YII_ENV') or define('YII_ENV', 'dev');
|
||||
|
||||
Usted puede definir `YII_ENV` como uno de los valores siguientes:
|
||||
|
||||
- `prod`: entorno de producción. La constante `YII_ENV_PROD` evaluará como verdadero. Este es el valor por defecto de `YII_ENV` si no lo define.
|
||||
- `prod`: entorno de producción. La constante `YII_ENV_PROD` evaluará como verdadero.
|
||||
Este es el valor por defecto de `YII_ENV` si no esta definida.
|
||||
- `dev`: entorno de desarrollo. La constante `YII_ENV_DEV` evaluará como verdadero.
|
||||
- `test`: entorno de pruebas. La constante `YII_ENV_TEST` evaluará como verdadero.
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
|
||||
Los eventos permiten inyectar código dentro de otro código existente en ciertos puntos de ejecución. Se pueden adjuntar
|
||||
código personalizado a un evento, cuando se lance (triggered), el código se ejecutará automáticamente. Por ejemplo, un
|
||||
objeto `mailer` puede lanzar el evento `messageSent` cuando se envía un mensaje correctamente. Si se quiere rastrear
|
||||
objeto mailer puede lanzar el evento `messageSent` cuando se envía un mensaje correctamente. Si se quiere rastrear
|
||||
el correcto envío del mensaje, se puede, simplemente, añadir un código de seguimiento al evento `messageSent`.
|
||||
|
||||
Yii introduce una clase base [[yii\base\Component]] para soportar eventos. Si una clase necesita lanzar un evento,
|
||||
@ -34,11 +34,12 @@ function ($event) {
|
||||
Un gestor de eventos puede obtener la siguiente información acerca de un evento ya sucedido mediante el parámetro
|
||||
`$event`:
|
||||
|
||||
- [[yii\base\Event::name|event name]]
|
||||
- [[yii\base\Event::sender|event sender]]: el objeto desde el que se ha ejecutado `trigger()`
|
||||
- [[yii\base\Event::name|nombre del evento]]
|
||||
- [[yii\base\Event::sender|evento enviando]]: el objeto desde el que se ha ejecutado `trigger()`
|
||||
- [[yii\base\Event::data|custom data]]: los datos que se proporcionan al adjuntar el gestor de eventos
|
||||
(se explicará más adelante)
|
||||
|
||||
|
||||
Añadir Gestores de Eventos <a name="attaching-event-handlers"></a>
|
||||
--------------------------
|
||||
|
||||
@ -95,7 +96,7 @@ $foo->on(Foo::EVENT_HELLO, function ($event) {
|
||||
De forma predeterminada, cada nuevo gestor añadido se pone a la cola de la lista de gestores del evento. Por lo tanto,
|
||||
el gestor se ejecutará en el último lugar cuando se lance el evento. Para insertar un nuevo gestor al principio de la
|
||||
cola de gestores para que sea ejecutado primero, se debe llamar a [[yii\base\Component::on()]], pasando al cuarto
|
||||
parámetro `$append` el valor `false`:
|
||||
parámetro `$append` el valor false:
|
||||
|
||||
```php
|
||||
$foo->on(Foo::EVENT_HELLO, function ($event) {
|
||||
@ -135,10 +136,10 @@ Con el código anterior, cada llamada a `bar()` lanzará un evento llamado `hell
|
||||
Tercero, se puede ver que eventos soporta una clase simplemente revisando la declaración de constantes.
|
||||
|
||||
A veces cuando se lanza un evento se puede querer pasar información adicional al gestor de eventos. Por ejemplo, un
|
||||
`mailer` puede querer enviar la información del mensaje para que los gestores del evento `messageSent` para que los
|
||||
mailer puede querer enviar la información del mensaje para que los gestores del evento `messageSent` para que los
|
||||
gestores puedan saber las particularidades del mensaje enviado. Para hacerlo, se puede proporcionar un objeto de tipo
|
||||
evento como segundo parámetro al método [[yii\base\Component::trigger()]]. El objeto de tipo evento debe ser una
|
||||
instancia de la clase [[yii\base\Event]] o de sus hijas. Por ejemplo:
|
||||
instancia de la clase [[yii\base\Event]] o de su clase hija. Por ejemplo:
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
@ -18,7 +18,7 @@ Instalación
|
||||
Yii 2.0 adopta íntegramente [Composer](https://getcomposer.org/), el administrador de paquetes de facto de PHP.
|
||||
Tanto la instalación del núcleo del framework como las extensiones se manejan a través de Composer. Por favor consulta
|
||||
la sección [Comenzando con la Aplicación Básica](start-installation.md) para aprender a instalar Yii 2.0. Si quieres crear extensiones
|
||||
o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta la sección [Creando Extensiones](extend-creating-extensions.md) de la guía.
|
||||
o transformar extensiones de Yii 1.1 para que sean compatibles con Yii 2.0, consulta la sección [Creando Extensiones](structure-extensions.md#creating-extensions) de la guía.
|
||||
|
||||
|
||||
Requerimientos de PHP
|
||||
@ -148,7 +148,7 @@ como `yii\web\Request` puede ser auto-cargada. Si estás utilizando una librerí
|
||||
como Zend Framework, puedes definir un path alias `@Zend` que se refiera al directorio de instalación
|
||||
de ese framework. Una vez realizado esto, Yii será capaz de auto-cargar cualquier clase de Zend Framework también.
|
||||
|
||||
Se puede encontrar más detalles del tema en la sección [Path Alias](concept-aliases.md).
|
||||
Se puede encontrar más detalles del tema en la sección [Alias](concept-aliases.md).
|
||||
|
||||
|
||||
Vistas
|
||||
@ -204,7 +204,7 @@ Ten en cuenta que dada la introducción de [[yii\base\Model::scenarios()|scenari
|
||||
En la mayoría de los casos, no necesitas sobrescribir [[yii\base\Model::scenarios()|scenarios()]] si el método [[yii\base\Model::rules()|rules()]]
|
||||
especifica completamente los escenarios que existirán, y si no hay necesidad de declarar atributos inseguros (`unsafe`).
|
||||
|
||||
Para aprender más detalles de modelos, consulta la sección [Modelos](basic-models.md).
|
||||
Para aprender más detalles de modelos, consulta la sección [Modelos](structure-models.md).
|
||||
|
||||
|
||||
Controladores
|
||||
@ -271,7 +271,7 @@ aplicados a cualquier archivo de vista, incluso una vista renderizada fuera del
|
||||
Además, el componente `CThemeManager` ya no existe. En cambio, `theme` es una propiedad configurable del componente `view`
|
||||
de la aplicación.
|
||||
|
||||
Consulta la sección [Utilizando Themes](tutorial-theming.md) para más detalles.
|
||||
Consulta la sección [Utilizando Themes](output-theming.md) para más detalles.
|
||||
|
||||
|
||||
Aplicaciones de Consola
|
||||
@ -337,7 +337,7 @@ Al registrar un asset bundle a través de [[yii\web\AssetBundle::register()]], h
|
||||
vía Web. A diferencia de Yii 1, la página que registra el bundle contendrá automáticamente las referencias a los archivos
|
||||
JavaScript y CSS especificados en el bundle.
|
||||
|
||||
Por favor, consulta la sección [Manejando Assets](output-assets.md) para más detalles.
|
||||
Por favor, consulta la sección [Manejando Assets](structure-assets.md) para más detalles.
|
||||
|
||||
|
||||
Helpers
|
||||
@ -469,6 +469,36 @@ Hay muchos otros cambios y mejoras con respecto a ActiveRecord. Por favor, consu
|
||||
la sección [Active Record](db-active-record.md) para más detalles.
|
||||
|
||||
|
||||
Active Record Behaviors
|
||||
-----------------------
|
||||
|
||||
En 2.0, hemos disminuido la clase del comportamiento base `CActiveRecordBehavior`.Si desea crear un comportamiento Active Record, usted tendrá que extender directamente de `yii\base\Behavior`. Si la clase de comportamiento debe responder a algunos eventos propio, usted tiene que anular los métodos `events()` como el siguiente,
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
use yii\db\ActiveRecord;
|
||||
use yii\base\Behavior;
|
||||
|
||||
class MyBehavior extends Behavior
|
||||
{
|
||||
// ...
|
||||
|
||||
public function events()
|
||||
{
|
||||
return [
|
||||
ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
|
||||
];
|
||||
}
|
||||
|
||||
public function beforeValidate($event)
|
||||
{
|
||||
// ...
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
User e IdentityInterface
|
||||
------------------------
|
||||
|
||||
@ -494,11 +524,11 @@ En 1.1, tendrías que haber creado dos reglas diferentes para obtener el mismo r
|
||||
]
|
||||
```
|
||||
|
||||
Por favor, consulta la sección [Documentación del Manejo de URLs](url.md) para más detalles.
|
||||
Por favor, consulta la sección [Documentación del Manejo de URLs](runtime-routing.md) para más detalles.
|
||||
|
||||
Utilizando Yii 1.1 y 2.x juntos
|
||||
-------------------------------
|
||||
|
||||
Si tienes código en Yii 1.1 que quisieras utilizar junto con Yii 2.0, por favor consulta
|
||||
la sección [Using Yii 1.1 and 2.0 Together](extend-using-v1-v2.md).
|
||||
la sección [Using Yii 1.1 and 2.0 Together](tutorial-yii-integration.md).
|
||||
|
||||
|
||||
@ -249,7 +249,7 @@ $component->detachBehaviors();
|
||||
Using `TimestampBehavior` <a name="using-timestamp-behavior"></a>
|
||||
-------------------------
|
||||
|
||||
To wrap up, let's take a look at [[yii\behaviors\TimestampBehavior]]. This behavior supports automatically
|
||||
To wrap up, let's take a look at [[yii\behaviors\TimestampBehavior]]. This behavior supports automatically
|
||||
updating the timestamp attributes of an [[yii\db\ActiveRecord|Active Record]] model anytime the model is saved (e.g., on insert or update).
|
||||
|
||||
First, attach this behavior to the [[yii\db\ActiveRecord|Active Record]] class that you plan to use:
|
||||
|
||||
Reference in New Issue
Block a user