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.

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;

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;

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.

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.

$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).

$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).

$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).

$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).

$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).

$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).

$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.

$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).

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).

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.

{{ 'css/example.css'|asset }}

Obtenha imagens brutas da mídia carregada no painel de administração usando o filtro media.

{{ 'example.jpg'|media }}

Obtenha miniaturas da mídia carregada no painel do administrador usando o filtro thumbnail.

{{ 'example.jpg'|thumbnail }}

Defina os URLs da página interna usando o filtro `link '.

{{ 'path/to/page'|link }}

Obtenha variáveis de ambiente no arquivo .env usando a função getenv.

{{ getenv('VARIABLE') }}

Aqui estão todas as variáveis globais disponíveis.

{# 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.

<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).

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.

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";

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.

// Adicione seu middleware aqui
$app->add($container->get('auth'));
$app->add($container->get('csrf'));

$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

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.

require_once __DIR__ . "/config/time.php";
require_once __DIR__ . "/config/image.php";
// Adicione seu contêiner aqui

require_once __DIR__ . "/config/example.php";

Depois disso, você pode usar o pacote usando a classe Slim\Container.

$container->get('package');
$this->container->get('package');

enio-infotera/esqueleto.md