Skip to content

Instantly share code, notes, and snippets.

@enio-infotera

enio-infotera/esqueleto.md

Created October 1, 2019 16:49
Show Gist options
  • Save enio-infotera/0905709aa36e01ddb4fb505bdb7b2f7e to your computer and use it in GitHub Desktop.
Save enio-infotera/0905709aa36e01ddb4fb505bdb7b2f7e to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. enio-infotera created this gist Oct 1, 2019.
    404 changes: 404 additions & 0 deletions esqueleto.md
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,404 @@
    # Esqueleto
    Ambiente de desenvolvimento rápido da Web, baseado na estrutura [Slim] (https://www.slimframework.com)

    ## Recursos
    - Com base na estrutura [Slim] (https://www.slimframework.com)
    - Biblioteca de gerenciamento de modelos [Twig] (https://twig.symfony.com)
    - Gerenciamento de banco de dados com a biblioteca [Eloquent ORM] (https://laravel.com/docs/5.7/eloquent)
    - Gerenciamento de correio com a biblioteca [Swift Mailer] (https://swiftmailer.symfony.com)
    - Manipulação de data e hora com a biblioteca [Carbon] (https://carbon.nesbot.com)
    - Gerenciamento do sistema de arquivos com a biblioteca [Filesystem] (https://github.com/symfony/filesystem)
    - Validação de entrada com a biblioteca [Validation] (https://github.com/rakit/validation)
    - Manipulação de imagens com a biblioteca [Image] (http://image.intervention.io)
    - Gerenciamento de sessões com a biblioteca [Slim Session] (https://github.com/bryanjhv/slim-session)
    - Proteção CSRF com a biblioteca [Slim CSRF] (https://github.com/slimphp/Slim-Csrf)
    - Sistema de autenticação de usuário simples pré-configurado e painel de administração

    ## Instalação

    ```
    $ composer create-project enio-dev/esqueleto <nome>
    ```
    ```
    $ git clone https://github.com/enio-dev/esqueleto.git
    ```

    ## Configuração
    As configurações básicas podem ser encontradas no arquivo `.env` e todas as configurações no arquivo` config/app.php`. Após a instalação, há poucas coisas que você precisa fazer manualmente.

    - Adicione `APP_KEY` no arquivo` .env`, que deve ter 16 caracteres. Verifique se ele possui caracteres especiais como `! @ # $ & *?` E combinação de números, caracteres maiúsculos e minúsculos. Não compartilhe com ninguém. Você precisará da chave do aplicativo para registrar os usuários back-end.
    - Importe `esqueleto.sql` usando [phpMyAdmin] (https://www.phpmyadmin.net) ou crie tabelas` users` e `media` manualmente. Após criar as tabelas do banco de dados, certifique-se de excluir o arquivo `esqueleto.sql`.
    ```sql
    CREATE TABLE `admin_accounts` (
    `id` int(11) NOT NULL,
    `activated` tinyint(1) NOT NULL DEFAULT 1,
    `unique_id` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `reset_token` varchar(191) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
    `username` varchar(16) COLLATE utf8mb4_unicode_ci NOT NULL,
    `email` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `password` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `logged_count` int(11) NOT NULL DEFAULT 0,
    `last_logged_at` varchar(191) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
    `created_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `updated_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci ROW_FORMAT=COMPACT;

    ALTER TABLE `admin_accounts`
    ADD PRIMARY KEY (`id`),
    ADD UNIQUE KEY `unique_id` (`unique_id`),
    ADD UNIQUE KEY `email` (`email`);

    ALTER TABLE `admin_accounts`
    MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
    ```
    ```sql
    CREATE TABLE `public_accounts` (
    `id` int(11) NOT NULL,
    `unique_id` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `activation_token` varchar(191) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
    `reset_token` varchar(191) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
    `username` varchar(16) COLLATE utf8mb4_unicode_ci NOT NULL,
    `email` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `password` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `logged_count` int(11) NOT NULL DEFAULT 0,
    `last_logged_at` varchar(191) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
    `created_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `updated_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci ROW_FORMAT=COMPACT;

    ALTER TABLE `public_accounts`
    ADD PRIMARY KEY (`id`),
    ADD UNIQUE KEY `unique_id` (`unique_id`),
    ADD UNIQUE KEY `email` (`email`),
    ADD UNIQUE KEY `activation_token` (`activation_token`);

    ALTER TABLE `public_accounts`
    MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
    ```
    ```sql
    CREATE TABLE `admin_media` (
    `id` int(11) NOT NULL,
    `name` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `width` int(11) NOT NULL,
    `height` int(11) NOT NULL,
    `size` int(11) NOT NULL,
    `created_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL,
    `updated_at` varchar(191) COLLATE utf8mb4_unicode_ci NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci ROW_FORMAT=COMPACT;

    ALTER TABLE `admin_media`
    ADD PRIMARY KEY (`id`),
    ADD UNIQUE KEY `name` (`name`);

    ALTER TABLE `admin_media`
    MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
    ```
    - Certifique-se de atualizar `APP_URL` no arquivo` .env` com o URL do seu aplicativo
    - Atualize `APP_MEDIA` no arquivo` .env` com seu caminho absoluto para o diretório `resources/media`
    - Certifique-se de definir `APP_ERRORS` verdadeiro no arquivo` .env` no modo de produção

    ## Variáveis ambientais
    Variáveis de ambiente podem ser encontradas no arquivo `.env`. Aqui está a referência para `.env`.

    - `APP_NAME` - Defina o nome do seu aplicativo
    - `APP_DESCRIPTION` - Defina a descrição do aplicativo
    - `APP_KEYWORDS` - Defina as palavras-chave do seu aplicativo
    - `APP_AUTHOR` - Defina o nome do autor do aplicativo. Provavelmente você.
    - `APP_URL` - Defina o URL do aplicativo ou ele quebrará o sistema
    - `APP_EMAIL` - Defina o email padrão do aplicativo
    - `APP_TIMEZONE` - Defina o fuso horário padrão do aplicativo
    - `APP_KEY` - Defina a chave do aplicativo aqui. Isso tem que ter 16 caracteres. Não compartilhe com ninguém. Todas as senhas serão hash com essa chave. Depois de definir a chave, não a altere, pois isso danificará o sistema. E provavelmente você precisará da chave do aplicativo para registrar usuários de back-end.
    - `APP_MEDIA` - Defina o caminho absoluto para fazer upload de mídia ou ele quebrará o sistema
    - `APP_ERRORS` - No modo de produção, defina-o como verdadeiro. As opções disponíveis são `true` e` false`.
    - `APP_HASH` - Define o método de hash da senha. Depois de definir o método, não o altere, pois isso danificará o sistema. As opções disponíveis são `bcrypt`,` argon2i` e `argon2id`.
    - `DB_DRIVER` - Defina o driver do banco de dados
    - `DB_HOST` - Define o host do banco de dados
    - `DB_DATABASE` - Define o nome do banco de dados
    - `DB_USERNAME` - Define o nome de usuário do banco de dados
    - `DB_PASSWORD` - Define a senha do banco de dados
    - `DB_CHARSET` - Define o conjunto de caracteres do banco de dados
    - `DB_COLLATION` - Definir agrupamento do banco de dados
    - `DB_PREFIX` - Defina o prefixo da tabela
    - `MAIL_HOST` - Define o host SMTP
    - `MAIL_PORT` - Defina a porta SMTP
    - `MAIL_USERNAME` - Defina o nome de usuário SMTP
    - `MAIL_PASSWORD` - Define a senha SMTP

    ## Controllers
    Os controladores de aplicativos podem ser encontrados no diretório `app/Controller`. Toda classe de controlador deve estender a classe `App\Controller\Common\Base`.

    ```php
    namespace App\Controller;

    use App\Controller\Base;
    use Slim\Http\Request;
    use Slim\Http\Response;

    class ExmpleController extends Base
    {
    public function exampleMethod(Request $request, Response $response, array $data)
    {
    // Código vai aqui
    }
    }
    ```

    Obtenha pacotes contidos nos controladores usando a variável `$this->container` do controlador `Base`.
    ```php
    $package = $this->container->get('package');
    ```

    Gerencie models em controladores usando o método `$this->view` no controlador `Base`. Para passar dados como variável [Twig] (https://twig.symfony.com), use a variável `$ this-> data` do controlador` Base`. Para mais informações, consulte [Twig documentation] (https://twig.symfony.com/doc/2.x).
    ```php
    $this->data['variable'] = "Some data";
    $this->view($response, 'example.twig');
    ```

    Envie mensagens nos controladores usando o método `$this->mail` do controlador `Base`. Para obter mais informações, consulte [documentação do Swift Mailer] (https://swiftmailer.symfony.com/docs/introduction.html).
    ```php
    $this->mail([
    'subject' => 'Mail Subject',
    'from' => ['John Doe' => '[email protected]'],
    'to' => ['Brad Peter' => '[email protected]'],
    'body' => 'Mail Body'
    ]);
    ```

    Manipule tempo e dados nos controladores usando a variável `$this->time` do controlador` Base`. Para mais informações, consulte [Documentação do Carbono] (https://carbon.nesbot.com/docs).
    ```php
    $this->time
    ```

    Gerencie o sistema de arquivos nos controladores usando a variável `$this->filesystem` do controlador `Base`. Para obter mais informações, consulte [Documentação do sistema de arquivos] (https://symfony.com/doc/current/components/filesystem.html).
    ```php
    $this->filesystem
    ```

    Valide os campos de entrada do formulário nos controladores usando o método `$this->validator` no controlador` Base`. Para obter mais informações, consulte [Documentação de validação] (https://github.com/rakit/validation/blob/master/README.md).
    ```php
    $validation = $this->validator($request, [
    'input' => 'required|min:6|max:16'
    ]);
    ```

    Manipule imagens nos controladores usando o método `$this->image` do controlador` Base`. Para mais informações, consulte [Documentação da imagem] (http://image.intervention.io).
    ```php
    $image = $this->image('path/to/image.jpg');
    ```

    Obtenha o usuário atual `id`,` nome de usuário`, `email`,` lastLogin` e `loginCount` usando o método` $this->authGet` do controlador `Base`. Para verificar se autenticado, use a variável `$this->authCheck` do controlador` Base`.
    ```php
    $this->authGet('username');
    ```

    ## Routes
    As rotas de aplicativos podem ser encontradas no arquivo `app/routes.php`. Para obter mais informações, consulte [documentação Slim] (https://www.slimframework.com/docs).
    ```php
    use App\Controller\ExampleController;

    $app->get('/example-route', ExampleController::class . ':exampleMethod');
    ```

    ## Models
    Os modelos de aplicativos podem ser encontrados no diretório `app/Model`. Toda classe de modelo deve estender a classe `Illuminate \ Database \ Eloquent\Model`. Para obter mais informações, consulte [documentação do Eloquent ORM] (https://laravel.com/docs/5.7/eloquent).
    ```php
    namespace App\Model;

    use Illuminate\Database\Eloquent\Model;

    class ExampleModel extends Model
    {
    public $timestamps = true;
    protected $table = "example";
    }
    ```

    ## Views
    As visualizações de aplicativos podem ser encontradas no diretório `resources/views` e todos os outros modelos podem ser encontrados no diretório` resources / views / common`. (Páginas de erro, modelo de correspondência etc.) Phyxle usa [Twig] (https://twig.symfony.com) como mecanismo de modelo. Você pode estender o Twig adicionando mais filtros ou funções ou variáveis globais que podem ser encontradas no diretório `app/Extension`. Para mais informações, consulte [Twig documentation] (https://twig.symfony.com/doc/2.x/).

    Defina assets usando o filtro `asset`.
    ```twig
    {{ 'css/example.css'|asset }}
    ```

    Obtenha imagens brutas da mídia carregada no painel de administração usando o filtro `media`.
    ```twig
    {{ 'example.jpg'|media }}
    ```

    Obtenha miniaturas da mídia carregada no painel do administrador usando o filtro `thumbnail`.
    ```twig
    {{ 'example.jpg'|thumbnail }}
    ```

    Defina os URLs da página interna usando o filtro `link '.
    ```twig
    {{ 'path/to/page'|link }}
    ```

    Obtenha variáveis de ambiente no arquivo `.env` usando a função` getenv`.
    ```twig
    {{ getenv('VARIABLE') }}
    ```

    Aqui estão todas as variáveis globais disponíveis.
    ```twig
    {# Obter nome do aplicativo #}
    {{ nome do aplicativo }}
    {# Obter descrição do aplicativo #}
    {{app.description}}
    {# Obter palavras-chave do aplicativo #}
    {{app.keywords}}
    {# Obter autor do aplicativo #}
    {{app.author}}
    {# Obter o URL do aplicativo #}
    {{app.url}}
    {# Obtenha a versão atual do PHP #}
    {{app.php}}
    {# Verifique se autenticado como administrador #}
    {{auth.admin.check}}
    {# Verifique autenticado como ID do usuário administrador}
    {{auth.admin.id}}
    {# Obter o nome de usuário do usuário administrador autenticado #}
    {{auth.admin.username}}
    {# Obtenha o email do usuário administrador autenticado #}
    {{auth.admin.email}}
    {# Obtenha o carimbo de data e hora do último login do usuário administrador autenticado #}
    {{auth.admin.login.last}}
    {# Obtenha a contagem de logon do usuário administrador autenticado #}
    {{auth.admin.login.count}}
    {# Verifique se autenticado como público #}
    {{auth.admin.check}}
    {# Obtenha o nome de usuário do usuário público autenticado #}
    {{auth.public.username}}
    {# Obtenha o email do usuário público autenticado #}
    {{auth.public.email}}
    {# Obtenha o carimbo de data e hora do último login do usuário público autenticado #}
    {{auth.public.login.last}}
    {# Obter número de logon do usuário público autenticado #}
    {{auth.public.login.count}}
    {# Obtenha a chave de nome CSRF #}
    {{csrf.name.key}}
    {# Obtenha o valor do nome CSRF #}
    {{csrf.name.value}}
    {# Obter chave de token CSRF #}
    {{csrf.token.key}}
    {# Obtenha o valor do token CSRF #}
    {{csrf.token.value}}
    ```

    **Nota:** Você deve usar os campos de nome e token CSRF em todos os formulários.
    ```twig
    <input name="{{ csrf.name.key }}" type="hidden" value="{{ csrf.name.value }}" />
    <input name="{{ csrf.token.key }}" type="hidden" value="{{ csrf.token.value }}" />
    ```

    ## Middleware
    O middleware do aplicativo pode ser encontrado no diretório `app/Middleware`. Para mais informações, acesse [Slim documentation] (https://www.slimframework.com/docs).

    ```php
    namespace App\Middleware;

    use Slim\Http\Request;
    use Slim\Http\Response;

    class ExampleMiddleware
    {
    public function __invoke(Request $request, Response $response, callable $next)
    {
    // Codigo aqui
    return $next($request, $response);
    }
    }
    ```

    Após criar ou instalar o middleware, primeiro você precisa adicionar seu middleware ao container. Para isso, crie um novo arquivo usando o nome do middleware no diretório `config/middleware`.```
    $ cd config/middleware
    $ touch example.php
    ```
    ```php
    use App\Middleware\ExampleMiddleware;
    use Slim\Container;
    $container['example'] = function(Container $container) {
    $example = new ExampleMiddleware;
    return $example;
    };
    ```
    Em seguida, carregue acima do contêiner no arquivo `index.php`. É importante adicionar linha de solicitação após outro middleware e antes dos pacotes.
    ```php
    require_once __DIR__ . "/config/middleware/csrf.php";
    require_once __DIR__ . "/config/middleware/auth.php";
    // Add your container here

    require_once __DIR__ . "/config/view.php";
    require_once __DIR__ . "/config/filesystem.php";
    ```
    ```php
    require_once __DIR__ . "/config/middleware/example.php";
    ```
    Depois disso, carregue seu middleware no arquivo `app / middleware.php`. É importante adicionar a linha superior requerida de todos os outros middlewares.
    ```php
    // Adicione seu middleware aqui
    $app->add($container->get('auth'));
    $app->add($container->get('csrf'));
    ```
    ```php
    $app->add($container->get('example'));
    ```

    ## Packages
    Você pode instalar pacotes usando o Composer. Para mais informações, consulte [Documentação do compositor] (https://getcomposer.org/doc).
    ```
    $ composer require <vendor>/<package>
    ```

    Assim como no middleware, após a instalação do pacote, primeiro você precisa adicionar o novo pacote de instalação ao contêiner. Para isso, crie um novo arquivo usando o nome do pacote no diretório `config`.
    ```
    $ cd config
    $ touch package.php
    ```

    ```php
    use Slim\Container;
    use Vendor\Package;

    $container['package'] = function(Container $container) {
    $package = new Package;
    return $package;
    };
    ```
    Em seguida, carregue acima do contêiner no arquivo `index.php`. É importante adicionar a linha de fundo requerida de todos os outros pacotes.
    ```php
    require_once __DIR__ . "/config/time.php";
    require_once __DIR__ . "/config/image.php";
    // Adicione seu contêiner aqui
    ```
    ```php
    require_once __DIR__ . "/config/example.php";
    ```
    Depois disso, você pode usar o pacote usando a classe `Slim\Container`.
    ```php
    $container->get('package');
    $this->container->get('package');
    ```