corcel
vel 10
Uma coleção de classes Model que permite obter dados diretamente de um banco de dados WordPress.
Corcel é uma coleção de classes PHP construídas sobre o Eloquent ORM (do framework Laravel), que fornece uma interface fluente para conectar e obter dados diretamente de um banco de dados WordPress.
Você pode usar WordPress como backend (painel de administração) ou CMS, para inserir posts, tipos personalizados, etc, e qualquer outro aplicativo PHP do outro lado consultando esses dados (como uma camada de modelo). É mais fácil usar o Corcel com o Laravel, mas você pode usá-lo com qualquer projeto PHP que use o Composer.
Compre-me um café | Siga Corcel no Twitter
| Laravel | Corcel |
|---|---|
| 5.1.x | ~2.1.0 |
| 5.2.x | ~2.2.0 |
| 5.3.x | ~2.3.0 |
| 5.4.x | ~2.4.0 |
| 5.5.x | ~2.5.0 |
| 5.6.x | ~2.6.0 |
| 5.7.x | ~2.7.0 |
| 5.8.x | ~2.8.0 |
| 6.0.x | ^3.0.0 |
| 7.0.x | ^4.0.0 |
| 8.0.x | ^5.0.0 |
| 9.0.x | ^6.0.0 |
| 10.0.x | ^7.0.0 |
| 11.0.x | ^8.0.0 |
Você precisa usar o Composer para instalar o Corcel em seu projeto:
composer require jgrossi/corcel
Corcel irá se registrar usando o Auto Discovery do Laravel.
Você terá que incluir CorcelServiceProvider em seu config/app.php :
' providers ' => [
/*
* Package Service Providers...
*/
Corcel Laravel CorcelServiceProvider::class,
]Agora configure nosso arquivo de configuração para garantir que seu banco de dados esteja configurado corretamente e para permitir que você registre tipos de postagens e códigos de acesso personalizados de uma maneira muito fácil:
Execute o seguinte comando Artisan em seu terminal:
php artisan vendor:publish --provider="CorcelLaravelCorcelServiceProvider"
Agora você tem um arquivo de configuração config/corcel.php , onde pode definir a conexão do banco de dados com tabelas do WordPress e muito mais.
Basta definir a connection de banco de dados que você deseja que seja usada pelo Corcel em config/corcel.php .
Suponhamos que você tenha as seguintes conexões de banco de dados em seu arquivo config/database.php :
// File: /config/database.php
' connections ' => [
' mysql ' => [ // for Laravel database
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' database ' => ' mydatabase ' ,
' username ' => ' admin '
'password' => 'secret',
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => '' ,
' strict ' => false ,
' engine ' => null ,
],
' wordpress ' => [ // for WordPress database (used by Corcel)
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' database ' => ' mydatabase ' ,
' username ' => ' admin ' ,
' password ' => ' secret ' ,
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => ' wp_ ' ,
' strict ' => false ,
' engine ' => null ,
],
], Neste caso você deve querer usar a conexão wordpress para Corcel, então basta configurá-la no arquivo de configuração do Corcel config/corcel.php :
' connection ' => ' wordpress ' , Aqui você deve configurar o banco de dados para atender aos requisitos do Corcel. Primeiro, você deve incluir o arquivo autoload do Composer, se ainda não estiver carregado:
require __DIR__ . ' /vendor/autoload.php ' ;Agora você deve definir os parâmetros do seu banco de dados WordPress:
$ params = [
' database ' => ' database_name ' ,
' username ' => ' username ' ,
' password ' => ' pa$$word ' ,
' prefix ' => ' wp_ ' // default prefix is 'wp_', you can change to your own prefix
];
Corcel Database:: connect ( $ params );Você pode especificar todos os parâmetros do Eloquent, mas alguns são padrão (mas você pode substituí-los).
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => ' wp_ ' , // Specify the prefix for WordPress tables, default prefix is 'wp_'Cada vez que você vê
Post::method(), se estiver usando sua própria classe Post (onde você define o nome da conexão), comoAppPostvocê deve usarAppPost::method()e nãoPost::method(). Todos os exemplos pressupõem que você já conhece essa diferença.
Nos exemplos, toda vez que você vir
Post::method()assumaCorcelModelPost::method().
// All published posts
$ posts = Post:: published ()-> get ();
$ posts = Post:: status ( ' publish ' )-> get ();
// A specific post
$ post = Post:: find ( 31 );
echo $ post -> post_title ; Opcionalmente, você pode criar seu próprio modelo Post (ou Page, ou qualquer outro) que estenda CorcelPost . Em seguida, defina o nome da conexão (se quiser substituir o nome padrão do Corcel) que você está usando, neste caso foo-bar :
Estender a classe
CorcelModelPostpode adicionar flexibilidade ao seu projeto, uma vez que você pode adicionar métodos e lógica customizados, de acordo com o que você precisa usar em seu banco de dados WordPress.
<?php // File: app/Post.php
namespace App ;
use Corcel Model Post as Corcel ;
class Post extends Corcel
{
protected $ connection = ' foo-bar ' ;
public function customMethod () {
//
}
}Então, agora você pode buscar dados do banco de dados WP usando sua própria classe:
$ posts = App Post:: all (); // using the 'foo-bar' connectionApenas lembre-se que você não precisa estender nossa classe
Post, você pode usarCorcelModelPoste todos os outros modelos sem nenhum problema.
NOTA: No Corcel v1 você pode salvar metadados usando o método
Post::save(). Isso não é mais permitido. Use os métodossaveMeta()oucreateMeta()(veja abaixo) para salvar a postagem meta.
Você também pode recuperar metadados de postagens.
// Get a custom meta value (like 'link' or whatever) from a post (any type)
$ post = Post:: find ( 31 );
echo $ post -> meta -> link ; // OR
echo $ post -> fields -> link ;
echo $ post -> link ; // OR Para criar ou atualizar metadados de um usuário basta usar os métodos saveMeta() ou saveField() . Eles retornam bool como o método save() do Eloquent.
$ post = Post:: find ( 1 );
$ post -> saveMeta ( ' username ' , ' jgrossi ' );Você também pode salvar muitos metadados ao mesmo tempo:
$ post = Post:: find ( 1 );
$ post -> saveMeta ([
' username ' => ' jgrossi ' ,
' url ' => ' http://jgrossi.com ' ,
]); Você também tem os métodos createMeta() e createField() , que funcionam como os métodos saveX() , mas são usados apenas para criação e retornam a instância criada PostMeta , em vez de bool .
$ post = Post:: find ( 1 );
$ postMeta = $ post -> createMeta ( ' foo ' , ' bar ' ); // instance of PostMeta class
$ trueOrFalse = $ post -> saveMeta ( ' foo ' , ' baz ' ); // boolean Existem múltiplas possibilidades de consultar postagens por seus campos personalizados (meta) usando escopos em uma classe Post (ou outro modelo que use a característica HasMetaFields ):
Para verificar se existe uma meta-chave, use o escopo hasMeta() :
// Finds a published post with a meta flag.
$post = Post::published()->hasMeta('featured_article')->first();
Se quiser corresponder com precisão um metacampo, você pode usar o escopo hasMeta() com um valor.
// Find a published post which matches both meta_key and meta_value.
$ post = Post:: published ()-> hasMeta ( ' username ' , ' jgrossi ' )-> first (); Se você precisar combinar vários metacampos, você também pode usar o escopo hasMeta() passando um array como parâmetro:
$ post = Post:: hasMeta ([ ' username ' => ' jgrossi ' ])-> first ();
$ post = Post:: hasMeta ([ ' username ' => ' jgrossi ' , ' url ' => ' jgrossi.com ' ])-> first ();
// Or just passing the keys
$ post = Post:: hasMeta ([ ' username ' , ' url ' ])-> first (); Se você precisar corresponder uma string que não diferencia maiúsculas de minúsculas ou combinar caracteres curinga, poderá usar o escopo hasMetaLike() com um valor. Isso usa um operador SQL LIKE , portanto use '%' como operador curinga.
// Will match: 'J Grossi', 'J GROSSI', and 'j grossi'.
$ post = Post:: published ()-> hasMetaLike ( ' author ' , ' J GROSSI ' )-> first ();
// Using % as a wildcard will match: 'J Grossi', 'J GROSSI', 'j grossi', 'Junior Grossi' etc.
$ post = Post:: published ()-> hasMetaLike ( ' author ' , ' J%GROSSI ' )-> first (); A classe Post tem suporte para "aliases", portanto, se você verificar a classe Post , deverá observar alguns aliases definidos no array estático $aliases , como title para post_title e content para post_content .
$ post = Post:: find ( 1 );
$ post -> title === $ post -> post_title ; // true Se você estiver estendendo a classe Post para criar sua própria classe, você também poderá usar $aliases . Basta adicionar novos aliases a essa propriedade estática dentro de sua própria classe e ela herdará automaticamente todos os aliases da classe pai Post :
class A extends Corcel Post
{
protected static $ aliases = [
' foo ' => ' post_foo ' ,
];
}
$ a = A:: find ( 1 );
echo $ a -> foo ;
echo $ a -> title ; // from Post class Para ordenar postagens você pode usar os escopos newest() e oldest() , tanto para as classes Post quanto User :
$ newest = Post:: newest ()-> first ();
$ oldest = Post:: oldest ()-> first (); Para solicitar postagens basta usar o método Eloquent paginate() :
$ posts = Post:: published ()-> paginate ( 5 );
foreach ( $ posts as $ post ) {
// ...
} Para exibir os links de paginação basta chamar o método links() :
{{ $ posts -> links () }} Se você deseja recuperar um campo personalizado criado pelo plugin Advanced Custom Fields (ACF), você deve instalar o plugin corcel/acf - clique aqui para mais informações - e chamar o campo personalizado assim:
$ post = Post:: find ( 123 );
echo $ post -> acf -> some_radio_field ;
$ repeaterFields = $ post -> acf -> my_repeater_name ;Para evitar consultas SQL desnecessárias, basta definir o tipo de campo que você está solicitando. Normalmente são necessárias duas consultas SQL para obter o tipo de campo, portanto, se você quiser especificá-lo, estará ignorando essas consultas extras:
$ post = Post:: find ( 123 );
echo $ post -> acf -> text ( ' text_field_name ' );
echo $ post -> acf -> boolean ( ' boolean_field_name ' ); Você também pode trabalhar com tipos de postagem personalizados. Você pode usar o método type(string) ou criar sua própria classe.
// using type() method
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();
// using your own class
class Video extends Corcel Post
{
protected $ postType = ' video ' ;
}
$ videos = Video:: status ( ' publish ' )-> get (); Usar o método type() fará com que Corcel retorne todos os objetos como CorcelPost . Utilizando sua classe customizada você tem a vantagem de customizar classes, incluindo métodos e propriedades customizadas, retornar todos os objetos como Video , por exemplo.
Tipos de postagem personalizados e metadados:
// Get 3 posts with custom post type (store) and show its address
$ stores = Post:: type ( ' store ' )-> status ( ' publish ' )-> take ( 3 )-> get ();
foreach ( $ stores as $ store ) {
$ storeAddress = $ store -> address ; // option 1
$ storeAddress = $ store -> meta -> address ; // option 2
$ storeAddress = $ store -> fields -> address ; // option 3
} Cada vez que você chama algo como Post::type('video)->first() ou Video::first() você recebe uma instância CorcelModelPost .
Se você optar por criar uma nova classe para seu tipo de postagem personalizado, poderá fazer com que essa classe seja retornada para todas as instâncias desse tipo de postagem.
Em vez de chamar o método Post::registerPostType() para todos os tipos de postagem personalizados que você deseja registrar, basta usar o arquivo de configuração do Corcel e mapear todos os posts personalizados e suas classes. Eles serão registrados automaticamente para você:
' post_types ' => [
' video ' => App Video::class,
' foo ' => App Foo::class,
]Portanto, toda vez que você consultar um tipo de postagem personalizado, a instância mapeada será retornada.
Isto é particularmente útil quando você pretende obter uma coleção de postagens de diferentes tipos (por exemplo, ao buscar as postagens definidas em um menu).
//all objects in the $videos Collection will be instances of Post
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();
// register the video custom post type and its particular class
Post:: registerPostType ( ' video ' , ' AppVideo ' )
//now all objects in the $videos Collection will be instances of Video
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();Você também pode fazer isso para classes integradas, como Page ou Post. Basta registrar a classe Page ou Post com a string de tipo de postagem associada e esse objeto será retornado em vez do padrão.
Você pode mapear todos os códigos de acesso desejados dentro do arquivo config/corcel.php , na chave 'shortcodes' . Neste caso você deve criar sua própria classe que implements a interface CorcelShortcode , que requer um método render() :
' shortcodes ' => [
' foo ' => App Shortcodes FooShortcode::class,
' bar ' => App Shortcodes BarShortcode::class,
],Este é um exemplo de classe de shortcode:
class FakeShortcode implements Corcel Shortcode
{
/**
* @param ShortcodeInterface $shortcode
* @return string
*/
public function render ( ShortcodeInterface $ shortcode )
{
return sprintf (
' html-for-shortcode-%s-%s ' ,
$ shortcode -> getName (),
$ shortcode -> getParameter ( ' one ' )
);
}
} Você pode adicionar códigos de acesso chamando o método addShortcode no modelo Post :
// [gallery id="1"]
Post:: addShortcode ( ' gallery ' , function ( $ shortcode ) {
return $ shortcode -> getName () . ' . ' . $ shortcode -> getParameter ( ' id ' );
});
$ post = Post:: find ( 1 );
echo $ post -> content ;O Laravel 5.5 usa a descoberta automática de pacotes, portanto não exige que você adicione manualmente o ServiceProvider
Se você estiver usando Laravel, sugerimos adicionar seus manipuladores de códigos de acesso em AppProvidersAppServiceProvider , no método boot .
Os códigos de acesso são analisados com a biblioteca Thunderer/shortcode .
Vários analisadores diferentes são fornecidos. RegularParser é o mais tecnicamente correto e é fornecido por padrão. Isto é adequado para a maioria dos casos. No entanto, se você encontrar algumas irregularidades na análise do shortcode, pode ser necessário configurar o Corcel para usar o WordpressParser , que corresponde mais fielmente ao regex do shortcode do WordPress. Para fazer isso, se você estiver usando o Laravel, edite o arquivo config/corcel.php e remova o comentário do seu analisador preferido. Como alternativa, você pode substituí-lo por um analisador próprio.
' shortcode_parser ' => Thunder Shortcode Parser RegularParser::class,
// 'shortcode_parser' => ThunderShortcodeParserWordpressParser::class, Se você não estiver usando Laravel, você pode fazer isso em tempo de execução, chamando o método setShortcodeParser() de qualquer classe que use o traço Shortcodes , como Post , por exemplo.
$ post -> setShortcodeParser ( new WordpressParser ());
echo $ post -> content ; // content parsed with "WordpressParser" classPara obter mais informações sobre o pacote shortcode, clique aqui.
Você pode obter taxonomias para uma postagem específica, como:
$ post = Post:: find ( 1 );
$ taxonomy = $ post -> taxonomies ()-> first ();
echo $ taxonomy -> taxonomy ;Ou você pode pesquisar postagens usando suas taxonomias:
$ post = Post:: taxonomy ( ' category ' , ' php ' )-> first (); Você também pode obter o formato da postagem, como a função get_post_format() do WordPress:
echo $ post -> getFormat (); // should return something like 'video', etc As páginas são como tipos de postagem personalizados. Você pode usar Post::type('page') ou a classe CorcelModelPage .
use Corcel Model Page ;
// Find a page by slug
$ page = Page:: slug ( ' about ' )-> first (); // OR
$ page = Post:: type ( ' page ' )-> slug ( ' about ' )-> first ();
echo $ page -> post_title ;Obtenha uma categoria ou taxonomia ou carregue postagens de uma determinada categoria. Existem várias maneiras de conseguir isso.
// all categories
$ cat = Taxonomy:: category ()-> slug ( ' uncategorized ' )-> posts -> first ();
echo " <pre> " ; print_r ( $ cat -> name ); echo " </pre> " ;
// only all categories and posts connected with it
$ cat = Taxonomy:: where ( ' taxonomy ' , ' category ' )-> with ( ' posts ' )-> get ();
$ cat -> each ( function ( $ category ) {
echo $ category -> name ;
});
// clean and simple all posts from a category
$ cat = Category:: slug ( ' uncategorized ' )-> posts -> first ();
$ cat -> posts -> each ( function ( $ post ) {
echo $ post -> post_title ;
}); Obtendo o anexo e/ou revisão de uma Post ou Page .
$ page = Page:: slug ( ' about ' )-> with ( ' attachment ' )-> first ();
// get feature image from page or post
print_r ( $ page -> attachment );
$ post = Post:: slug ( ' test ' )-> with ( ' revision ' )-> first ();
// get all revisions from a post or page
print_r ( $ post -> revision ); Obtendo a miniatura de uma Post ou Page .
$ post = Post:: find ( 1 );
// Retrieve an instance of CorcelModelMetaThumbnailMeta.
print_r ( $ post -> thumbnail );
// For convenience you may also echo the thumbnail instance to get the URL of the original image.
echo $ post -> thumbnail ; Para recuperar um tamanho de miniatura específico você pode chamar o método ->size() no objeto miniatura e passar um parâmetro de string de tamanho de miniatura (por exemplo, thumbnail ou medium ). Se a miniatura tiver sido gerada, este método retornará uma matriz de metadados de imagem, caso contrário, o URL da imagem original será retornado como substituto.
if ( $ post -> thumbnail !== null ) {
/**
* [
* 'file' => 'filename-300x300.jpg',
* 'width' => 300,
* 'height' => 300,
* 'mime-type' => 'image/jpeg',
* 'url' => 'http://localhost/wp-content/uploads/filename-300x300.jpg',
* ]
*/
print_r ( $ post -> thumbnail -> size ( Corcel Model Meta ThumbnailMeta:: SIZE_THUMBNAIL ));
// http://localhost/wp-content/uploads/filename.jpg
print_r ( $ post -> thumbnail -> size ( ' invalid_size ' ));
}Nas versões anteriores do Corcel esta classe era chamada de
Optionsem vez deOption(singular). Portanto tome cuidado em usar sempre esta classe no singular a partir dev2.0.0.
O método
Option::getAll()foi removido no Corcel 2+, em favor deOption::asArray($keys []).
Você pode usar a classe Option para obter dados da tabela wp_options :
$ siteUrl = Option:: get ( ' siteurl ' );Você também pode adicionar novas opções:
Option:: add ( ' foo ' , ' bar ' ); // stored as string
Option:: add ( ' baz ' , [ ' one ' => ' two ' ]); // this will be serialized and savedVocê pode obter todas as opções em um array simples:
$ options = Option:: asArray ();
echo $ options [ ' siteurl ' ];Ou você pode especificar apenas as chaves que deseja obter:
$ options = Option:: asArray ([ ' siteurl ' , ' home ' , ' blogname ' ]);
echo $ options [ ' home ' ]; Para obter um menu pelo seu slug, use a sintaxe abaixo. Os itens de menu serão carregados na variável items (é uma coleção de objetos CorcelModelMenuItem ).
Os itens de menu atualmente suportados são: Páginas, Postagens, Links Personalizados e Categorias.
Assim que você tiver instâncias da classe MenuItem , se quiser usar a instância original (como a Página ou Termo original, por exemplo), basta chamar o método MenuItem::instance() . O objeto MenuItem é apenas uma postagem com post_type igual nav_menu_item :
$ menu = Menu:: slug ( ' primary ' )-> first ();
foreach ( $ menu -> items as $ item ) {
echo $ item -> instance ()-> title ; // if it's a Post
echo $ item -> instance ()-> name ; // if it's a Term
echo $ item -> instance ()-> link_text ; // if it's a custom link
} O método instance() retornará o objeto correspondente:
Post para item de menu post ;Page para item de menu page ;CustomLink para item de menu custom ;Term para item de menu category .Para lidar com menus de vários níveis, percorra todos os itens do menu para colocá-los nos níveis corretos, por exemplo.
Você pode usar o método MenuItem::parent() para recuperar a instância pai desse item de menu:
$ items = Menu:: slug ( ' foo ' )-> first ()-> items ;
$ parent = $ items -> first ()-> parent (); // Post, Page, CustomLink or Term (category) Para agrupar itens de menu de acordo com seus pais, você pode usar o método ->groupBy() na coleção $menu->items , agrupando itens de menu por seu $item->parent()->ID .
Para ler mais sobre o método groupBy() dê uma olhada na documentação do Laravel.
Você pode manipular os usuários da mesma maneira que trabalha com postagens:
// All users
$ users = User:: get ();
// A specific user
$ user = User:: find ( 1 );
echo $ user -> user_login ; Se você estiver usando o Laravel 5.4 ou anterior, certifique-se de ter o provedor CorcelServiceProvider registrado.
E então, defina o provedor do usuário em config/auth.php para permitir que o Laravel faça login com usuários do WordPress:
' providers ' => [
' users ' => [
' driver ' => ' corcel ' ,
' model ' => Corcel Model User::class,
],
], Agora você pode usar a fachada Auth para autenticar usuários:
Auth:: validate ([
' email ' => ' [email protected] ' , // or using 'username' too
' password ' => ' secret ' ,
]); Para fazer a redefinição de senha do Laravel funcionar com o Corcel, temos que substituir como as senhas são armazenadas no banco de dados. Para fazer isso, você deve alterar Auth/PasswordController.php de:
use App Http Controllers Controller ;
use Illuminate Foundation Auth ResetsPasswords ;
class PasswordController extends Controller
{
use ResetsPasswords;para
use App Http Controllers Controller ;
use Illuminate Foundation Auth ResetsPasswords ;
use Corcel Laravel Auth ResetsPasswords as CorcelResetsPasswords ;
class PasswordController extends Controller
{
use ResetsPasswords, CorcelResetsPasswords {
CorcelResetsPasswords::resetPassword insteadof ResetsPasswords;
} Você pode usar a classe AuthUserProvider para autenticar manualmente um usuário:
$ userProvider = new Corcel Laravel Auth AuthUserProvider ;
$ user = $ userProvider -> retrieveByCredentials ([ ' username ' => ' admin ' ]);
if (! is_null ( $ user ) && $ userProvider -> validateCredentials ( $ user , [ ' password ' => ' admin ' ])) {
// successfully login
}Lembre-se de que você pode usar
usernamee
Para executar os testes do phpunit, execute o seguinte comando:
./vendor/bin/phpunit
Se você tiver o comando global phpunit instalado, basta digitar:
phpunit
Todos os testes foram escritos usando Sqlite com banco de dados :memory , para que ele rode na sua memória. Todos os testes utilizam factories e migrations . Dê uma olhada nos diretórios tests/database/factories e tests/database/migrations para obter mais informações.
Todas as contribuições são bem-vindas para ajudar a melhorar o Corcel.
Antes de enviar sua solicitação pull (PR), considere as seguintes diretrizes:
Fork https://github.com/corcel/corcel no Github;
Clone seu repositório bifurcado (não o do Corcel) localmente e crie seu próprio branch com base na versão que você deseja corrigir ( 2.1 , 2.2 , 2.3 , 2.4 ou 2.5 ): git checkout -b my-fix-branch 2.5 ;
Faça todas as alterações no código. Lembre-se aqui de escrever pelo menos um caso de teste para qualquer recurso adicionado ou qualquer correção de bug (se ainda não tiver sido testado). Nosso objetivo é ter 100% do código coberto por testes, então ajude-nos a escrever um código melhor ;-) Se você não tem experiência com testes é uma boa oportunidade para aprender. Basta dar uma olhada em nossos casos de teste e você verá como eles são simples.
Execute os testes de unidade localmente para garantir que suas alterações não quebraram nenhum outro trecho de código;
Envie seu novo branch para seu repositório bifurcado, normalmente git push origin HEAD deve funcionar;
No GitHub novamente, crie uma solicitação pull (PR) de sua ramificação my-fix-branch personalizada (de seu repositório bifurcado) para a ramificação relacionada ( corcel:2.5 , por exemplo, não corcel:master , por favor;
Aguarde a aprovação :-)
Licença MIT © Junior Grossi
