FuelPHP - Guia rápido

FuelPHP é uma estrutura de aplicativo da web de código aberto. Ele foi escrito em PHP 5.3 e implementa o padrão HMVC.HMVC é Hierarchical Model-View-Controller framework que permite sub-requisitar ao controlador, que retorna a página parcial como comentários, menus, etc., ao invés da página completa como no MVC normal.

FuelPHP foi criado com o desejo de incorporar as melhores práticas de frameworks como CodeIgniter e Kohanacom melhorias e ideias próprias. A ferramenta de migração de banco de dados FuelPHP e as funcionalidades de scaffolding são inspiradas no popularRuby on Rails estrutura.

• FuelPHP aproveita o power of command line através de um utilitário chamado "Oil". O utilitário foi projetado para ajudar a acelerar o desenvolvimento, aumentar a eficiência, testes, depuração e suporte a HTML.

• FuelPHP é puramente uma abordagem orientada a objetos. Sua arquitetura é baseada na ideia de modularidade. Os aplicativos podem ser divididos em módulos e cada componente pode ser estendido ou substituído sem reescrever uma única linha de código. Fuel suporta qualquer analisador de template, comoSmarty, Twig, PHPTal, etc. para analisar visualizações.

• FuelPHP community is largee ativo com mais de 300 colaboradores. Sua grande comunidade cria e melhora regularmente pacotes e extensões. O principal objetivo do framework FuelPHP é fornecer flexibilidade e compatibilidade. É rápido, fácil de aprender e uma solução completa para o desenvolvimento de aplicações web.

• O que torna o FuelPHP um dos principais frameworks usados ​​por desenvolvedores de PHP é que - o new version of FuelPHP is reverse-compatible with its older versionspor causa de sua API estável. É extremamente flexível.

• Packages and modulestorna mais fácil e simples reutilizar um código existente de maneira sistemática. FuelPHP oferece desempenho máximo por meio de uma pequena biblioteca. Sua depuração interativa permite eliminar facilmente os erros de desenvolvimento. Além disso, seu código limpo e estável torna a programação mais fácil.

FuelPHP - Recursos

O FuelPHP oferece muitos recursos para criar um aplicativo da web completo. Ele fornece componentes flexíveis, configuração simples, ORM fácil de usar, modo de desenvolvimento de aplicativo baseado em REST, etc. A seguir estão alguns dos recursos mais importantes -

• Estrutura da web flexível e voltada para a comunidade
• fácil de configurar e usar
• FuelPHP é extremamente portátil, funciona em quase qualquer servidor
• Sistema de roteamento URI flexível
• FuelPHP fornece suporte de desenvolvimento de API RESTful
• Modelo ORM leve
• Filtragem de entrada e evita injeção de SQL
• Estrutura de autenticação e autorização segura
• Código reutilizável e mais fácil de manter
• Autoloading classes, gerenciamento de sessão e tratamento de exceções.

FuelPHP - vantagens

FuelPHP é um elegante framework HMVC PHP 5.3 que fornece um conjunto de componentes para a construção de aplicativos da web com as seguintes vantagens -

• Modular structure- O combustível não o força a usar módulos ou uma estrutura de arquivo HMVC. Se você quiser usar, o processo é bastante fácil de integrar. Os aplicativos FuelPHP são criados em uma estrutura modular e se tornam mais fáceis para os desenvolvedores com benefícios claros.

• HMVC pattern - A característica mais importante deste framework é o HMVC (Hierarchical Model View Controller) que torna fácil acessar ou usar quaisquer propriedades, métodos de classe, funções, arquivos de nível superior.

• Secure hashing function- FuelPHP suporta ferramentas de criptografia fortes e técnicas de hashing de senha. Ele lida com criptografia, descriptografia e hash usando o poderoso PHPSecLib.

• Scaffolding functionality- Scaffolding é um método de meta-programação para construir operações de banco de dados. O andaime do Fuel é muito fácil. Ele permite que você obtenha um aplicativo CRUD básico com etapas muito simples.

Os seguintes produtos populares usam FuelPHP Framework -

• Matic Technology- Fornecedor global de soluções de desenvolvimento de software customizado offshore. Na Matic Technologies, eles fornecem todas as melhores soluções possíveis através do FuelPHP de acordo com os requisitos do cliente.

• Kroobe- Kroobe é uma empresa de classificados de rede social. A Fuel oferece custos de desenvolvimento extremamente baixos e serviços para a equipe Kroobe para alcançar uma solução eficiente.

Este capítulo explica como instalar o framework FuelPHP em sua máquina. A instalação do FuelPHP é muito simples e fácil. Você tem dois métodos para criar aplicativos FuelPHP -

• O primeiro método é Command line instalação usando a ferramenta FuelPHP chamada Oil.

• O segundo método é Composer basedinstalação. FuelPHP usaComposer, tanto para instalação quanto para dependências de pacote, portanto, certifique-se de que o composer esteja instalado localmente antes de continuar o processo.

Vamos examinar cada um dos métodos, um por um, em detalhes nas seções subsequentes.

Requisitos de sistema

Antes de passar para a instalação, os seguintes requisitos de sistema devem ser satisfeitos.

Servidor Web (qualquer um dos seguintes)

• WAMP (Windows)
• Microsoft IIS (Windows)
• LAMP (Linux)
• MAMP (Macintosh)
• XAMP (multiplataforma)
• Nginx (multiplataforma)
• Servidor da web de desenvolvimento embutido em PHP (multiplataforma)

Suporte ao navegador (qualquer um dos seguintes)

• IE (Internet Explorer 8+)
• Firefox
• Google Chrome
• Safari

PHP compatibility- PHP 5.3 ou posterior. Para obter o máximo benefício, use a versão mais recente.

Vamos usar o servidor de desenvolvimento da web embutido em PHP para este tutorial. O servidor web de desenvolvimento integrado é fácil de iniciar, bem como bastante adequado para entender os fundamentos do aplicativo da web FuelPHP sem entrar na complexidade do mundo do servidor web e das configurações.

Instalação de linha de comando

A instalação da linha de comando do FuelPHP é muito fácil e leva no máximo cinco minutos.

Instale o pacote de óleo

Oil é um pacote / comando especial fornecido pelo framework FuelPHP para fazer muitas tarefas necessárias no desenvolvimento de um aplicativo FuelPHP, incluindo instalação, desenvolvimento e teste do aplicativo.

Para instalar o Oil pacote, abra um shell e execute o seguinte comando -

sudo curl https://get.fuelphp.com/oil | sh

O comando usa curl para baixar e instalar o pacote de óleo. O comando mostrará resultado semelhante às informações a seguir e, finalmente, instalará o pacote de óleo.

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current 
                                 Dload  Upload   Total   Spent    Left  Speed 
100   479  100   479    0     0    353      0  0:00:01  0:00:01 --:--:--   353

Crie um novo projeto

Para criar um novo projeto usando Oil, use o seguinte comando -

oil create <project_name>

Vamos criar um novo projeto chamado “HelloWorld” usando o seguinte comando.

oil create HelloWorld

Agora, você pode ver uma resposta semelhante à seguinte e, finalmente, criar um aplicativo de esqueleto simples do FuelPHP.

composer create-project fuel/fuel HelloWorld 
Installing fuel/fuel (1.8.0.1) 
   - Installing fuel/fuel (1.8.0.1) 
      Loading from cache  

Created project in HelloWorld  

Loading composer repositories with package information 
Updating dependencies (including require-dev) 
   - Installing composer/installers (v1.3.0) 
      Loading from cache
   - Installing fuelphp/upload (2.0.6) 
      Loading from cache  
   - Installing michelf/php-markdown (1.4.0) 
      Loading from cache  
   - Installing psr/log (1.0.2) 
      Loading from cache  
   - Installing monolog/monolog (1.18.2) 
      Loading from cache  
   - Installing phpseclib/phpseclib (2.0.0) 
      Loading from cache  
   - Installing fuel/core (1.8.0.4) 
      Loading from cache  
   - Installing fuel/auth (1.8.0.4) 
      Loading from cache  
   - Installing fuel/email (1.8.0.4) 
      Loading from cache  
   - Installing fuel/oil (1.8.0.4) 
      Loading from cache  
   - Installing fuel/orm (1.8.0.1) 
      Loading from cache  
   - Installing fuel/parser (1.8.0.4) 
      Loading from cache  
   - Installing fuel/docs (1.8.0.4) 
      Loading from cache
   ……………. 
   …………….  
   Writing lock file
   Generating autoload files

Versão do óleo

Para testar se o óleo está disponível e verificar a versão, use o seguinte comando -

$ cd HelloWorld $ php oil -v

O comando acima produz o seguinte resultado -

Fuel: 1.8 running in "development" mode

Comando de ajuda de óleo

Para obter a documentação de ajuda básica do Oil, use o seguinte comando -

$ php oil help

O comando acima irá mostrar a documentação de ajuda semelhante ao seguinte resultado -

Usage: 
   php oil [cell|console|generate|package|refine|help|server|test]  
Runtime options: 
   -f, [--force]    # Overwrite files that already exist 
   -s, [--skip]     # Skip files that already exist 
   -q, [--quiet]    # Supress status output 
   -t, [--speak]    # Speak errors in a robot voice  
Description:   
   The 'oil' command can be used in several ways to facilitate quick development, help 
   with testing your application and for running Tasks.  
Environment: 
   If you want to specify a specific environment oil has to run in, overload the 
   environment variable on the commandline: FUEL_ENV=staging php oil <commands>
More information: 
   You can pass the parameter "help" to each of the defined command to get 
   information about that specific command: php oil package help  
Documentation:   
   http://docs.fuelphp.com/packages/oil/intro.html

A partir de agora, você tem uma ideia de como instalar Combustível com Óleo. Vamos examinar a instalação baseada no composer na próxima seção.

Instalação baseada no Composer

O seguinte comando é usado para instalar o FuelPHP usando o Composer.

$ composer create-project fuel/fuel --prefer-dist.

Clones de repositório Git

Para instalar a versão de desenvolvimento mais recente como clones do repositório git local, use o seguinte comando.

$ composer create-project fuel/fuel:dev-1.9/develop --prefer-source.

Executando o aplicativo

Mova para a pasta pública do diretório do projeto, execute o aplicativo usando o servidor de produção com o seguinte comando.

$ cd path/to/HelloWorld/public
$ php -S localhost:8080 index.php

Ele produz a seguinte resposta.

PHP 5.5.31 Development Server started at Sun May 21 12:26:10 2017
Listening on http://localhost:8080
Document root is /Users/workspace/php-fuel/HelloWorld/public
Press Ctrl-C to quit.

Agora, solicite o URL, http://localhost:8080 e produzirá o seguinte resultado.

Resultado

Esta é a maneira mais simples de executar o aplicativo FuelPHP no ambiente de desenvolvimento. Se você criar seu aplicativo dessa maneira no ambiente de produção, terá problemas de segurança. A maneira recomendada é definir uma configuração de host virtual. É explicado para o servidor web apache na próxima seção.

Configurando um Host Virtual

É uma maneira mais segura de acessar o aplicativo FuelPHP. Para configurar um host virtual, você precisa vincular o arquivo de host virtual apache ao seu aplicativo. No caso do aplicativo de intranet, redirecione a URL do arquivo do host do sistema para o host virtual.

Arquivo de host virtual

Abra o host virtual e adicione as seguintes alterações.

<VirtualHost *:80> 
   ServerName hello.app 
   DocumentRoot /path/to/public 
   SetEnv FUEL_ENV “development”
   
   <Directory /path/to/public> 
      DirectoryIndex index.php 
      AllowOverride All 
      Order allow,deny 
      Allow from all 
   </Directory> 
</VirtualHost>

Arquivo de host do sistema

Agora, adicione uma entrada de host à sua máquina usando o seguinte comando.

sudo vi /etc/hosts

Em seguida, adicione a seguinte linha ao final do arquivo.

127.0.0.1 hello.app

Para disponibilizar todas as mudanças, reinicie seu servidor Apache e solicite o url, http://hello.app. Ele produz a página inicial do FuelPHP.

FuelPHP é baseado em testes de batalha Model-View-Controller arquitetura junto com HMVC (Hierarchical MVC)Apoio, suporte. Embora o MVC forneça desenvolvimento de aplicativos flexível e em camadas, o HMVC vai um passo além para permitir o widgetization do aplicativo da web.

O ponto forte do FuelPHP é que ele não impõe maneiras específicas de desenvolver um aplicativo. Ele apenas fornece uma estrutura padrão simples e fácil de usar. Os desenvolvedores são livres para usar o conjunto predefinido de funcionalidade fornecido pelo FuelPHP ou modificá-lo sempre que necessário. Todos os recursos fornecidos pelo FuelPHP, incluindo o recurso principal, podem ser alterados de acordo com os requisitos do aplicativo.

Modelo

O modelo é a entidade comercial do aplicativo. Controller e View trocam dados na forma de Model. O modelo permite a representação uniforme de nossos dados de negócios. Ele permite que a camada de banco de dados interaja com a camada de aplicativo da web da maneira padrão e fornece uma opção para selecionar, salvar, editar e excluir nossas entidades de banco de dados.

Controlador

Um aplicativo MVC típico começa a partir de um controlador. Depois que um usuário envia uma solicitação ao aplicativo da web FuelPHP, o aplicativo reúne todas as informações sobre a solicitação e as envia ao Controlador. O controlador faz a lógica de negócios necessária da página solicitada e, em seguida, chama a Visualização relevante junto com os dados processados ​​na forma de Modelos.

Visão

Visualização é a camada de apresentação do aplicativo MVC. View decide como mostrar o modelo ao usuário. Ele suporta a renderização de dados simples para o layout avançado, o que permite que o site normalize o design em todas as páginas. O View também fornece suporte a temas, o que permite mudanças rápidas de design em todo o aplicativo.

Apresentador

Presenter é um recurso especial fornecido pelo FuelPHP. É a cola entre o controlador e a visualização. O controlador pode compartilhar algumas de suas responsabilidades de baixo nível, como recuperar o modelo do banco de dados, gerar dados para a visualização, etc. O controlador chama o Presenter em vez de View, que por sua vez chama a View. O Presenter permite a separação pura da lógica de negócios e da camada de apresentação.

MVC hierárquico

O FuelPHP oferece uma opção de chamar um controlador de outro controlador, semelhante à solicitação do cliente (navegador). Se qualquer controlador chamar outro controlador, o controlador chamado retornará a resposta ao controlador de chamada em vez de renderizá-la ao cliente (navegador). Isso permitewidgetizationdo aplicativo da web. Por exemplo, a seção de comentários pode ser exibida como uma página independente e também como uma subseção da página principal (blog).

Módulo

Um dos recursos salientes do FuelPHP é que uma seção do aplicativo da web pode ser convertida em módulos, que podem ser compartilhados entre os diferentes aplicativos. Por exemplo, um módulo de blog criado para um aplicativo pode ser reutilizado em outro aplicativo apenas copiando o código do módulo do aplicativo de origem para o aplicativo de destino.

Observe que criar um novo módulo é tão simples quanto desenvolver o aplicativo principal. A estrutura é semelhante à do aplicativo principal, com a única exceção de que o módulo deve codificar uma pasta separada.

Pacote

FuelPHP fornece uma opção para organizar o código em uma única unidade chamada Pacote. Um pacote pode conter uma ou mais funcionalidades necessárias para o aplicativo da web. Por exemplo, um componente de banco de dados como ORM, e-mail, etc., pode ser organizado em um pacote e usado sempre que necessário.

Um Pacote é diferente de um Módulo no sentido de que o Pacote não contém nenhuma página da web ou páginas da web parciais. O pacote pode ser usado no FuelPHP, bem como em qualquer outro framework PHP.

Fluxo de Trabalho

O fluxo de trabalho do FuelPHP é simples e fácil de entender. Isso é descrito no diagrama a seguir.

• O usuário envia uma solicitação ao aplicativo.

• O controlador recebe a solicitação e reúne informações ao interagir com o modelo, que por sua vez interage com o banco de dados.

• O controlador reúne informações ao interagir com outro controlador, enviando uma sub-solicitação para os outros controladores.

• O controlador envia o modelo recuperado para a visualização, que por sua vez gera a apresentação e a envia ao cliente como uma resposta.

• Em alguns casos, o controlador pode passar o controle para o apresentador. Nesse caso, o apresentador coleta informações do modelo e as envia ao cliente. Aqui, o apresentador não executa nenhuma lógica de negócios, exceto recuperar o modelo do banco de dados.

Neste capítulo, veremos como criar um aplicativo simples no framework FuelPHP. Conforme discutido anteriormente, você sabe como criar um novo projeto no Fuel. Podemos dar um exemplo de detalhes do funcionário.

Vamos começar criando um projeto chamado Employee usando o seguinte comando.

oil create employee

Depois de executar o comando, um employee projeto é criado com o seguinte file structure -

employee 
├── CHANGELOG.md 
├── composer.json 
├── composer.lock 
├── composer.phar 
├── CONTRIBUTING.md 
├── fuel 
│   ├── app 
│   │   ├── bootstrap.php 
│   │   ├── cache 
│   │   ├── classes 
│   │   ├── config 
│   │   ├── lang 
│   │   ├── logs 
│   │   ├── migrations 
│   │   ├── modules 
│   │   ├── tasks 
│   │   ├── tests 
│   │   ├── themes 
│   │   ├── tmp 
│   │   ├── vendor 
│   │   └── views 
│   ├── core 
│   │   ├── base56.php 
│   │   ├── base.php 
│   │   ├── bootstrap.php
│   │   ├── bootstrap_phpunit.php 
│   │   ├── classes 
│   │   ├── composer.json 
│   │   ├── config 
│   │   ├── CONTRIBUTING.md 
│   │   ├── lang 
│   │   ├── phpunit.xml 
│   │   ├── tasks 
│   │   ├── tests 
│   │   ├── vendor 
│   │   └── views 
│   ├── packages 
│   │   ├── auth 
│   │   ├── email 
│   │   ├── oil 
│   │   ├── orm 
│   │   └── parser 
│   └── vendor 
│       ├── autoload.php 
│       ├── composer 
│       ├── fuelphp 
│       ├── michelf 
│       ├── monolog 
│       ├── phpseclib 
│       └── psr 
├── LICENSE.md 
├── oil 
├── public 
│   ├── assets 
│   │   ├── css 
│   │   ├── fonts 
│   │   ├── img 
│   │   └── js 
│   ├── favicon.ico 
│   ├── index.php 
│   └── web.config 
├── README.md 
└── TESTING.md  
42 directories, 21 files

Estrutura do aplicativo

O framework FuelPHP fornece uma estrutura de aplicativo bem organizada. Vamos verificar alguns dos arquivos e pastas importantes do aplicativo.

• fuel - Contém todos os arquivos PHP.

• public - Contém todos os ativos que são acessados ​​diretamente por meio do navegador, como JavaScript, CSS, imagens, etc.

• oil- Um executável usado para executar tarefas de linha de comando, como geração de código ou depuração interativa em seu aplicativo. É opcional.

• fuel/app/- Contém todos os arquivos PHP específicos do aplicativo. Ele contém modelos, visualizações e controladores.

• fuel/core/ - É aqui que a própria estrutura do Fuel mora.

• fuel/packages/- Contém todos os pacotes de combustível. Por padrão, o combustível conterá três pacotes: óleo, autenticação e orm. Esses pacotes não serão carregados a menos que você os solicite.

• fuel/app/config/- Contém todos os arquivos de configuração relacionados ao aplicativo. O arquivo de configuração principal do aplicativo, o arquivo config.php, está localizado aqui.

• fuel/app/classes/- Contém todos os arquivos PHP baseados em MVC específicos do aplicativo. Ele contém controladores, modelos, classes auxiliares, bibliotecas, etc.

• fuel/app/classes/controller/ - Os controladores são colocados aqui.

• fuel/app/classes/model/ - Os modelos são colocados aqui.

• fuel/app/views/- Contém arquivos de visualização. Não há convenções de nomenclatura específicas para visualizações.

Adicionar um controlador

Conforme discutido anteriormente, FuelPHP é baseado no padrão de desenvolvimento Model-View-Controller (MVC). MVC é uma abordagem de software que separa a lógica do aplicativo da apresentação. No padrão MVC, o controlador desempenha um papel importante e cada página da web em um aplicativo precisa ser tratada por um controlador. Por padrão, os controladores estão localizados emfuel/app/classes/controller/pasta. Você pode criar sua própria classe Controller aqui.

Mova para o local fuel / app / classes / controller / e crie o arquivo employee.php. Para criar um novo controlador, basta estender a classe Controller fornecida pelo FuelPHP, definida a seguir.

funcionário.php

<?php 
   class Controller_Employee extends Controller { 
      public function action_home() { 
         
         // functionality of the home page  
         echo "FuelPHP-Employee application!"; 
      } 
   }

Agora, criamos um Employee Controller e adicionamos um método público, action_home, que imprime um texto simples.

Encaminhamento

O roteamento resolve o URI da página da web em um controlador e ação específicos. Cada página da web em um aplicativo FuelPHP deve passar pelo roteamento antes da execução real do controlador. Por padrão, cada controlador pode ser resolvido usando o seguinte padrão de URI.

<controller>/<action>

Onde,

• controller é o nome do controlador menos o namespace, funcionário

• action é o nome do método menos ação_ palavra-chave, home

O controlador recém-criado pode ser acessado por http://localhost:8080/employee/home e produzirá o seguinte resultado.

Resultado

Neste capítulo, vamos entender como configurar um aplicativo FuelPHP. Por padrão, os arquivos de configuração são armazenados dentro dofuel/app/configpasta. A configuração principal do aplicativo éfuel/app/config/config.php. A configuração é especificada usando o array associado do PHP.

Visão geral

Por padrão, todos os arquivos de configuração padrão são definidos em fuel/core/configpasta. Para substituir uma configuração padrão, adicione a chave correspondente no/fuel/app/config/config.phparquivo e modifique o valor. Podemos usar a “notação de ponto” para simplificar a matriz multidimensional. Por exemplo, as configurações a seguir têm a mesma finalidade (carregar pacotes especificados).

array("always_load" => array("packages" => array( ... ) ) ); 
always_load.packages = array( ... );

A configuração pode ser agrupada por propósito e especificada usando diferentes arquivos, como db.php para configuração do banco de dados, package.php para gerenciamento de pacotes, etc.

Tipo de formato de configuração

FuelPHP é bastante flexível e fornece um formato diferente para especificar a configuração. O formato de configuração padrão é PHP usando array php. As outras opções são -

INI - Configuração simples baseada em texto suportada por muitos softwares, incluindo a própria linguagem PHP.

[group]
key = value

YAML - Fácil de entender, baseado em indentação e gerenciamento de configuração legível por humanos.

group:
   key: value

JSON - Formato de arquivo fácil de entender e mais utilizado pelos desenvolvedores.

{ 
   "group" : 
   { 
      "key": "value" 
   } 
}

Memcached- Armazena a configuração em um servidor memcached. Os detalhes do servidor memcached podem ser especificados no arquivo de configuração principal,fuel/app/config/config.php usando config.memcached entrada.

DB- Armazena a configuração no sistema RDBMS. A estrutura da tabela de configuração é a seguinte.

CREATE TABLE IF NOT EXISTS `config` ( 
   `identifier` char(100) NOT NULL, 
   `config` longtext NOT NULL, 
   `hash` char(13) NOT NULL, 
   PRIMARY KEY (`identifier`) 
)

Os detalhes do banco de dados e da tabela podem ser especificados no arquivo de configuração usando as entradas config.database e config.table_name .

Meio Ambiente

O ambiente permite que o FuelPHP funcione em modos diferentes carregando configurações diferentes. FuelPHP suporta o seguinte ambiente.

• Development - \ Fuel :: DEVELOPMENT define o modo de desenvolvimento

• Production - \ Combustível :: PRODUÇÃO define o modo de produção

• Test - \ Fuel :: TEST define o modo de teste

• Staging - \ Fuel :: STAGING define o modo de teste

FuelPHP também suporta a criação de um novo ambiente. Isso permitirá que cada desenvolvedor tenha sua própria definição de configuração e eles podem ativá-la enquanto codificam e testam o aplicativo. A configuração de um ambiente específico pode ser adicionada simplesmente criando uma pasta com o nome do ambiente (exemplo: teste) e colocando o arquivo de configuração dentro da pasta recém-criada, conforme mostrado a seguir.

. ├── config.php 
├── db.php 
├── development 
│   └── db.php 
├── production 
│   └── db.php 
├── routes.php 
├── staging 
│   └── db.php
└── test 
    └── db.php  
4 directories, 7 files

Defina seu ambiente

Existem três maneiras de configurar seu ambiente.

Option 1- Definir ambiente com variáveis ​​de ambiente do servidor web. Adicione o seguinte código na seção de host virtual emhttpd.confarquivo do servidor web Apache. Pode ser adicionado em.htaccess arquivo também.

SetEnv FUEL_ENV production

Option 2 - Definir o ambiente com o arquivo de bootstrap FuelPHP, /fuel/app/bootstrap.php

Fuel::$env = (isset($_SERVER['FUEL_ENV']

Option 3 - Definir ambiente usando óleo

$ env FUEL_ENV = production php oil -v

Ele produz o seguinte resultado.

Fuel: 1.8 running in "production" mode

Controllerssão responsáveis ​​por lidar com cada solicitação que chega ao aplicativo FuelPHP. De acordo com o FuelPHP, os controladores estão localizados emfuel/app/classes/controller/. Vamos primeiro criar um controlador de funcionário.

funcionário.php

<?php  
   class Controller_Employee extends Controller { 
      public function action_home() { 
         echo "FuelPHP-Employee application!"; 
      }  
      
      public function action_index() { 
         echo "This is the index method of employee controller"; 
      } 
   }

Métodos de controle

Os controladores processam uma solicitação da web usando um de seus action_ métodos. Podemos criar tantos métodos action_ dependendo dos requisitos do aplicativo. O método action_ padrão é action_index . O método action_index pode ser chamado por qualquer um dos seguintes URLs.

http://localhost:8080/employee/index
http://localhost:8080/employee/

Resultado

Vamos criar um novo actionmétodo, action_show em nossoemployee inscrição.

<?php  
   class Controller_Employee extends Controller { 
      public function action_home() { 
         echo "FuelPHP-Employee application!"; 
      }  
      public function action_index() { 
         echo "This is the index method of employee controller"; 
      }  
      public function action_show() { 
         echo "This is the show method of employee controller"; 
      } 
   }

O método action_show pode ser chamado usando a seguinte URL.

http://localhost:8080/home/show

Resultado

Método before ()

Podemos criar um método, beforeem nosso controlador. Este método será executado antes de cada invocação do método action_ . Ele não será chamado se esse método não existir. Este método nos ajuda a escrever ações comuns, como verificação de login, busca de dados padrão, etc.

Vamos criar um método before e imprimir uma mensagem de texto simples.

public function before() { 
   echo "This message comes from <em>before()</em> method</br>"; 
}

Página de índice com antes da ação

Mostrar página antes da ação

Método after ()

after() método é semelhante a before()método, mas executado após o método action_ ser chamado. O método after () recebe a resposta como uma entrada e retorna o objeto de resposta .

public function after($response) { if ( ! $response instanceof Response) { 
      $response = \Response::forge($response, $this->response_status); } return $response; 
}

Se a entrada for objeto NULL ou não resposta, em seguida, criar uma nova Response objeto usando o método de forja de Resposta e devolvê-lo. Aprenderemos a classe Response em detalhes nos capítulos subsequentes.

Estendendo controladores

Podemos estender um controlador de outro controlador. A seguir está a sintaxe básica.

class Controller_Employee extends Controller_Welcome { 
   // controller methods 
}

Isso ajudará no compartilhamento de métodos.

Gerar controlador

O combustível tem a opção de gerar controlador usando o comando Óleo. A seguir está a sintaxe.

Sintaxe

oil g controller <controller-name>

Exemplo

oil g controller sample

Depois de executar o comando acima, você verá a seguinte resposta.

Resultado

Creating view: /path/to/project/fuel/app/views/template.php 
Creating view: /path/to/project/fuel/app/views/sample/index.php 
Creating controller: /path/to/project/fuel/app/classes/controller/sample.php

Tipo de controladores

O FuelPHP fornece diferentes tipos de controlador para diversos fins. Eles são os seguintes -

• Controlador de base
• Controlador de modelo
• Controlador de descanso
• Controlador híbrido

Controlador de base

O controlador é o controlador básico para todos os diferentes tipos de controladores disponíveis no FuelPHP. Ele fornece todas as funcionalidades básicas necessárias para processar uma solicitação da web. Ele suporta Solicitação, Resposta, Sessão, etc. Nós o usaremos em todos os exemplos, a menos que especificado de outra forma.

Controlador de modelo

Um controlador de modelo é uma extensão do controlador de base. Possui suporte a templates, métodos pré-definidos antes () e depois (). Basicamente, ele pode ser usado para envolver sua visão em um layout com um cabeçalho, rodapé, barra lateral, etc. Para criar um controlador de modelo, precisamos estender a classe Controller_Template . Por padrão, todos os métodos de uma classe que estende Controller_Template precisam usar o modelo.

É definido como segue.

class Controller_Employee extends Controller_Template { 
   public function action_index() { 
      // add methods 
   } 
}

Discutiremos mais sobre o controlador de template no capítulo Views.

Controlador de descanso

Um controlador de descanso é uma extensão do controlador de base. Possui suporte pré-definido para programação de API REST. Isso permitirá que você crie APIs com facilidade.

Para criar o controlador de descanso, você precisa estender a classe Controller_Rest . É definido como segue.

class Controller_Employee extends Controller_Rest { 
   public function action_index() { 
      // add methods 
   } 
}

Discutiremos mais sobre o controlador de descanso no capítulo Ajax.

Controlador Híbrido

O controlador híbrido executa a funcionalidade do controlador REST e do controlador de modelo em um único controlador de base.

Os mapas de roteamento solicitam um URI para um método de controlador específico. Neste capítulo, discutiremos o conceito derouting em FuelPHP em detalhes.

Configuração

O arquivo de configuração de rotas está localizado em fuel/app/config/routes.php. O padrãoroutes.php arquivo é definido da seguinte forma -

<?php 
   return array ( 
      '_root_'  => 'welcome/index',   // The default route 
      '_404_'   => 'welcome/404',     // The main 404 route 
      'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'), 
   );

Aqui, _root_é a rota padrão predefinida, que será correspondida quando o aplicativo for solicitado com o caminho da raiz, / por exemplo, http: // localhost: 8080 / . O valor de _root_ é o controlador e a ação a ser resolvida quando houver correspondência.welcome/indexresolve para controlador Controller_Welcome e método de ação action_index . Da mesma forma, temos as seguintes rotas reservadas.

• root - A rota padrão quando nenhum URI é especificado.

• 403 - É gerado quando HttpNoAccessException é encontrado.

• 404 - Retorna quando a página não é encontrada.

• 500 - É gerado quando HttpServerErrorException é encontrado.

Roteamento Simples

A rota é comparada ao URI da solicitação. Se uma correspondência for encontrada, a solicitação é roteada para o URI. O roteamento simples é descrito a seguir,

return array ( 
   'about'  => 'site/about', 
   'login' => 'employee/login', 
);

Aqui, about corresponde a http: // localhost: 8080 / about e resolve o controlador, Controller_Site e método de ação, action_about

login corresponde a http: // localhost: 8080 / login e resolve o controlador, Controller_Login e método de ação, action_login

Roteamento Avançado

Você pode incluir qualquer regex em suas rotas. O combustível suporta os seguintes recursos avançados de roteamento -

• :any - Corresponde a qualquer coisa daquele ponto em diante no URI, não corresponde a “nada”

• :everything - Como: qualquer, mas também corresponde a “nada”

• :segment - Corresponde a apenas 1 segmento no URI, mas esse segmento pode ser qualquer coisa

• :num - Corresponde a qualquer número

• :alpha - Corresponde a qualquer caractere alfa, incluindo UTF-8

• :alnum - Corresponde a qualquer caractere alfanumérico, incluindo UTF-8

Por exemplo, a seguinte rota corresponde ao URI http: // localhost: 8080 / hello / FuelPHP e resolve o controlador, Controller_Welcome e ação action_hello

'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'),

O método de ação correspondente em Controller_Welcome é o seguinte,

public function action_hello() { 
   $this->name = Request::active()->param('name', 'World'); $message = "Hello, " . $this->name; echo $message; 
}

Aqui, usamos a classe Request para obter o parâmetro de nome do URL. Se o nome não for encontrado, estamos usando World como valor padrão. Aprenderemos a classe Request no capítulo Request and Response .

Resultado

Ação de método HTTP

FuelPHP oferece suporte a rotas para corresponder às ações prefixadas do método HTTP. A seguir está a sintaxe básica.

class Controller_Employee extends Controller { 
   public function get_index() { 
      // called when the HTTP method is GET. 
   }  
   public function post_index(){ 
      // called when the HTTP method is POST. 
   } 
}

Podemos rotear seus URLs para controladores e ações com base no verbo HTTP no arquivo de configuração da seguinte maneira.

return array ( 
   // Routes GET /employee to /employee/all and POST /employee to /employee/create 
   ‘employee’ => array(array('GET', new Route(‘employee/all')), array('POST', 
      new Route(‘employee/create'))), 
);

A solicitação e a resposta HTTP desempenham um papel importante em qualquer aplicativo da web. Precisamos obter os detalhes completos da solicitação http para processá-la adequadamente. Uma vez processados, precisamos enviar os dados processados ​​ao cliente por meio de resposta http.

FuelPHP fornece excelente Request e Responseclasse para ler e escrever solicitação HTTP e resposta HTTP, respectivamente. Vamos aprender sobre ambosRequest e Response classe neste capítulo.

Solicitação

Em um aplicativo da Web típico, o aplicativo precisa analisar os detalhes da solicitação atual. A classe Request fornece métodos simples para analisar a solicitação atual a ser processada pelo aplicativo. A solicitação também fornece uma opção para criar uma nova solicitação agindo como um cliente http.

A criação de uma nova solicitação permite que o aplicativo solicite outra parte do aplicativo ou totalmente outro aplicativo e mostre o resultado. Vamos aprender como analisar a solicitação de entrada neste capítulo e aprender como criar uma nova solicitação no capítulo Solicitação HMVC.

Analisando uma solicitação

A classe Request fornece três métodos para obter os detalhes da solicitação http. Eles são os seguintes,

active - É um método estático, que retorna a solicitação http ativa atual.

$currentRequest = Request::active();

param - retorna o valor do parâmetro especificado. Ele contém dois argumentos. O primeiro argumento é o nome do parâmetro e o segundo argumento é o valor a ser retornado, se o parâmetro não estiver disponível na solicitação http atual.

$param = Request::active()->param('employee_name', 'none');

params - É o mesmo que param, exceto que retorna todos os parâmetros como uma matriz.

$params = Request::active()->params();

Exemplo

Vamos criar um formulário simples e processar o formulário usando a classe de solicitação.

Step 1- Crie uma nova ação, action_request no controlador de funcionário.

public function action_request() { 
}

Step 2 - Chame os métodos de solicitação para obter todos os parâmetros da solicitação atual.

public function action_request() { 
   $params = Request::active()->params(); 
}

Step 3 - Despeje a matriz de parâmetro buscada.

public function action_request() { 
   $params = Request::active()->params(); echo dump($params); 
}

Step 4- Altere o roteamento para incluir os parâmetros no arquivo de configuração da rota, fuel / app / config / routes.php

'employee/request(/:name)?' => array('employee/request', 'name' => 'name'),

Agora, solicitando a nova ação, http: // localhost: 8080 / employee / request / Jon, ele mostrará a seguinte resposta.

Resposta

A classe de resposta fornece opções para criar uma resposta http. Por padrão, não precisamos usar uma classe de resposta diretamente na maioria das situações. Em vez disso, usamos View (que aprenderemos no próximo capítulo) para criar uma resposta http. View oculta a resposta http do desenvolvedor e a envia ao cliente usando a classe Response subjacente . Em uma situação avançada, usamos a classe Response diretamente e criamos uma resposta http completa.

Criação de uma resposta

A resposta consiste em cabeçalhos e corpo. O cabeçalho principal é o código de status http. O código de status Http são códigos padrão definidos no protocolo HTTP para descrever a resposta. Por exemplo, um código de status 200 significa que a solicitação foi bem-sucedida.

A classe Response fornece três argumentos para criar a resposta http,

• $body - corpo da resposta http

• $status_code - código de status da resposta http

• $headers - cabeçalhos opcionais como matriz

$body = "Hi, FuelPHP"; 
$headers = array ( 'Content-Type' => 'text/html', ); $response = new Response($body, 200, $headers);

Vamos criar uma nova ação, action_response no controlador de funcionário da seguinte maneira.

public function action_response() { 
   $body = "Hi, FuelPHP"; $headers = array ('Content-Type' => 'text/html',); 
   $response = new Response($body, 200, $headers); return $response; 
}

Resultado

Métodos

A classe de resposta fornece vários métodos para manipular respostas http. Eles são os seguintes,

forge - É o mesmo que o construtor da classe de resposta, conforme visto acima.

return Response::forge("Hi, FuelPHP", 404);

redirect- Oferece a opção de redirecionar para uma URL em vez de enviar uma resposta. Ele contém os seguintes argumentos,

a.url- url de destino b. método - métodos de redirecionamento. localização (padrão) e atualização c . redirect_code - código de status http. O valor padrão é 302.

// use a URL 
Response::redirect('http://some-domain/index', 'refresh');  

// or use a relative URI 
Response::redirect('employee/list');

redirect_back- É semelhante ao método de redirecionamento, exceto que redireciona para a página anterior. Podemos especificar a página de redirecionamento, se nenhuma página posterior estiver disponível.

// If there is no back page, go to the employee list page 
Response::redirect_back('/employee/list', 'refresh');

set_status - Fornece uma opção para definir o código de status http.

$response = new Response(); $response->set_status(404);

set_header - Fornece uma opção para definir os cabeçalhos http.

$response = new Response(); $response->set_header('Content-Type', 'application/pdf');  

// replace previous value using third arguments 
$response->set_header('Content-Type', 'application/pdf', 'text/plain');

set_headers - é igual a set_header exceto que fornece uma opção para definir vários cabeçalhos usando array.

$response = new Response(); 
$response->set_headers (array 
   'Content-Type' => 'application/pdf', 
   'Pragma' => 'no-cache', 
));

get_header - Permite obter os detalhes do cabeçalho definidos anteriormente.

$response = new Response(); 
$response->set_header('Pragma', 'no-cache'); // returns 'no-cache' $header = $response->get_header('Pragma'); // returns array('Pragma' => 'no-cache') $header = $response->get_header();

body - Fornece uma opção para definir o corpo da resposta http.

$response = new Response(); 
$response->body('Hi, FuelPHP'); // returns 'Hi, FuelPHP' $body = $response->body();

send_headers- Envia os cabeçalhos ao cliente solicitado. O FuelPHP usa esse método para enviar a resposta ao cliente. Normalmente, não precisamos usar este método.

$response->send_headers();

send - O mesmo que send_headers, exceto que os cabeçalhos podem ser restritos na resposta http.

// send the headers as well 
$response->send(true); // only send the body $response->send(false); 
$response->send();

Viewé a camada de apresentação do aplicativo MVC. Ele separa a lógica do aplicativo da lógica da apresentação. Quando um controlador precisa gerar HTML, CSS ou qualquer outro conteúdo, ele encaminha a tarefa para o mecanismo de visualização.

O FuelPHP fornece uma classe simples e flexível, View, com todos os recursos necessários de um view engine. A classe de visualização suporta renderização de arquivo de visualização O arquivo de visualização é uma página HTML com instruções PHP incorporadas. As variáveis ​​do arquivo de visão podem ser definidas usando a classe View como array PHP e referenciadas no arquivo de visão usando a chave do array. Vamos verificar alguns dos métodos importantes da classe View.

forja

• Purpose - Cria um novo objeto View

• Parameter - A seguir estão os parâmetros

  • $file - Caminho do arquivo de visualização em relação à pasta de visualizações, fuel / app / views

  • $data - Matriz de valores

  • $filter - Define a codificação automática, os padrões são as configurações no arquivo de configuração principal

• Returns - Instância da vista

Por exemplo,

$view = View::forge ('path/to/view', array( 'title' => "Show employee, 'employees' => $employees, 
));

filtro automático

• Purpose - Defina se codificará os dados ou não

• Parameter - A seguir está o parâmetro

  • $filter - verdadeiro / falso

• Returns - Objeto de visualização atual

Por exemplo,

$view->auto_filter(); 
$view = $view->auto_filter(false);

set_filename

• Purpose - Permite definir ou alterar o arquivo de visualização.

• Parameter - A seguir está o parâmetro -

  • $file - Caminho para visualizar o arquivo em relação à pasta de visualizações, combustível / app / visualizações

• Returns - Objeto de visualização atual

Por exemplo,

$view = new View();
$view>set_filename('path/to/view');

conjunto

• Purpose - Defina o valor de uma ou mais variáveis

• Parameter - A seguir estão os parâmetros

  • $key - Nome da variável ou matriz de valores

  • $value - Valor / nulo

  • $filter - Configuração de codificação, verdadeiro / falso

• Returns - Objeto de visualização atual

Por exemplo,

$view = new View(); $view->set(array('name' => 'Jon'));

set_global

set_global é semelhante a set, exceto que se aplica a todas as visualizações e as variáveis ​​são acessíveis por todas as visualizações. Este é um método estático.

View::set_global('name', 'Jon', false);

set_safe

• Purpose - Defina o valor de uma ou mais variáveis ​​com codificação segura ativada.

• Parameter - A seguir estão os parâmetros -

  • $key - Nome da variável ou matriz de valores

  • $value - Valor / nulo

• Returns - Objeto de visualização atual

Por exemplo,

$view = new View(); $view->set_safe(array('name' => 'Jon'), null);

pegue

• Purpose - Obtenha o valor de uma ou mais variáveis

• Parameter - A seguir estão os parâmetros

  • $key - Nome da variável

  • $default - Valor padrão a ser retornado se a chave não for encontrada

• Returns - Valor da chave de entrada

Por exemplo,

$view = new View(); $name = $view>get('name');  // name = 'Jon'

render

• Purpose - Renderizar os arquivos de visualização em string, mesclando-os com as variáveis ​​locais e globais

• Parameter - A seguir estão os parâmetros -

  • $file - O nome do arquivo de visualização

• Returns - O arquivo de visualização renderizado como string

Por exemplo,

$html = View::forge()->render('/path/to/view');

Criar uma vista

Para entender as visualizações, vamos modificar o método de ação, action_show do controlador, Controller_Employee .

funcionário.php

<?php  
   class Controller_Employee extends Controller { 
      public function action_show() {
         return View::forge('employee/show'); 
      } 
   }

Agora crie uma pasta funcionário no diretório de visualizações, localizado em fuel / app / views . Então, crie um arquivo show.php dentro da pasta de funcionários e adicione o seguinte código.

show.php

<h3> My first view </h3>

Agora, solicite a url http: // localhost: 8080 / employee / show e produz o seguinte resultado.

Passando dados para ver

Podemos passar dados para as visualizações usando métodos de visualização conforme discutido anteriormente. A seguir está um exemplo simples.

funcionário.php

class Controller_Employee extends Controller { 
   public function action_show() { 
      $data = array(); //stores variables going to views 
      $data['name'] = ‘Jon’; $data[‘job’] = ‘Designer’;  
      
      //assign the view to browser output 
      return View::forge('employee/show', $data); 
   } 
}

Agora, adicione as mudanças no view Arquivo.

show.php

<html> 
   <body> 
      Hello, <?php echo $name; ?>. 
      Your job is, <?php echo $job; ?>. 
   </body> 
</html>

Depois de solicitar o URL, ele exibirá o nome e o trabalho da seguinte forma -

Ver filtro

As visualizações usam codificação de saída para passar o que você quiser. Se você quiser passar dados não filtrados, podemos usar o método set.

funcionário.php

class Controller_Employee extends Controller { 
   public function action_show() { 
      $view = \View::forge('employee/show'); 
      $view->set('name', 'Jon', true); $view->set('job', '<em>Designer</em>', false); 
      return $view; 
   } 
}

Depois de solicitar o URL, ele exibirá os detalhes do trabalho com ênfase, conforme a seguir.

Vistas aninhadas

FuelPHP suporta visualizações aninhadas. Em visualizações aninhadas, uma visualização pode conter uma ou mais visualizações. Para definir as visualizações em outra visualização, podemos usar o método de renderização da seguinte maneira.

funcionário.php

class Controller_Employee extends Controller { 
   public function action_nestedview() { 
      
      //assign variables 
      $data = array(); 
      $data['title'] = 'Home'; $data['name'] = 'Jon'; 
      $data['job'] = 'Designer'; $views = array(); 
      $views['head'] = View::forge('head', $data)->render(); 
      $views['content'] = View::forge('employee/show', $data)->render();  
      return View::forge('layout', $views, false)->render(); 
   } 
}

fuel / app / views / layout.php

<html> 
   <head> 
      <?php echo $head; ?> 
   </head> 
   
   <body> 
      <?php echo $content; ?> 
   </body> 
</html>

fuel / app / views / head.php

<title>
   <?php echo $title; ?>
</title>

fuel / app / views / employee / show.php

Hello, <?php echo $name; ?>. Your job is, <?php echo $job; ?>.

Depois de solicitar a URL, http: // localhost: 8080 / employee / nestedview e verificar a visualização da fonte, ele fornece o seguinte código.

<html> 
   <head> 
      <title>Home</title> 
   </head> 
   
   <body> 
      Hello, Jon. 
      Your job is, Designer. 
   </body> 
</html>

Controlador de modelo

FuelPHP fornece um controlador, Controller_Template, com conceito de layout integrado. O conceito de layout é feito usandobefore() e after()método do controlador. Para usar o controlador de modelo, precisamos estender o controlador usando Controller_Template em vez de Controller. Ao usar o método after () / before (), precisamos chamar parent :: before e parent :: after, caso contrário, o template quebra.

<?php 
   class Controller_Test extends Controller_Template { 
      public function before() { 
         parent::before(); 
         // do stuff 
      } 
        
      public function after($response) { $response = parent::after($response); // do stuff return $response; 
      } 
   }

template.php

É um arquivo de modelo padrão no Fuel. O arquivo de modelo é usado para chamar JS, CSS, HTML e chamar visualizações parciais. Está localizado emfuel/app/views/. Os modelos são usados ​​para envolver sua visão em um layout com cabeçalho, rodapé, barra lateral, etc. Podemos alterar o modelo padrão usando a variável $ template no método de ação a seguir.

fuel / app / classes / controller / test.php

<?php  
   class Controller_Test extends Controller_Template { 
      public $template = 'template_test'; 
      public function action_index() { 
         $this->template->title = 'Example Page'; $this->template->content = View::forge('test/index'); 
      } 
   }

fuel / app / views / template_test.php

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title><?php echo $title; ?></title> <?php echo Asset::css('bootstrap.css'); ?> </head> <body> <div> <?php echo $content; ?>
      </div> 
   </body> 
</html>

fuel / app / views / test / index.php

<h3>My Test page</h3>

Agora, solicite a URL http: // localhost: 8080 / test e produz o seguinte resultado.

Resultado

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <title>Example Page</title> 
      <link type = "text/css" rel = "stylesheet" 
         href = "http://localhost:8080/assets/css/bootstrap.css?1464964766" />
   </head> 
   
   <body> 
      <div> 
         <h3>My Test page</h3> 
      </div> 
   </body> 
</html>

Gerar página de visualização

Você pode gerar uma página de exibição usando o console de óleo de combustível. A seguir está a sintaxe básica.

oil g controller <controller-name> <page1> <page2> ..

Para gerar um controlador de administrador com páginas iniciais e de login, use o seguinte comando.

oil g controller admin home login

Resultado

Creating view: /path/to/app/fuel/app/views/admin/home.php 
Creating view: /path/to/app/fuel/app/views/admin/login.php 
Creating controller: /path/to/app/fuel/app/classes/controller/admin.php

O FuelPHP fornece uma camada adicional após o controlador para gerar visualizações. Uma vez que o controlador processa a entrada e conclui a lógica de negócios, ele envia o controle para oPresenter, que cuida da lógica extra, como buscar dados do banco de dados, definir dados de exibição, etc. e, em seguida, chama o objeto Exibir.

Podemos renderizar as visualizações usando a classe Presenter da seguinte maneira -

fuel / app / classes / controller / employee.php

public Controller_Employee extends Controller { 
   public function action_welcome() { 
      return Presenter::forge('employee/hello'); 
   } 
}

O local padrão da classe do apresentador é fuel / app / classes / presenter / . A seguir está um exemplo simples.

fuel / app / classes / presenter / employee / hello.php

<?php  
   class Presenter_Employee_Hello extends Presenter { 
      public function view() { 
         $this->name = Request::active()->param('name', 'World'); 
      } 
   }

O arquivo de visualização da classe do apresentador acima é resolvido para employee / hello.php relativo à pasta de visualizações , que é especificada.

fuel / app / views / employee / hello.php

<h3>Hi, <?php echo $name; ?></h3>

Por fim, altere a rota para corresponder à ação de boas-vindas do funcionário, mostrada a seguir -

fuel / app / config / routes.php

'employee/hello(/:name)?' => array('employee/welcome', 'name' => 'hello'),

Agora, solicitando a URL, http: // localhost: 8080 / employee / hello / Jon renderiza o seguinte resultado.

Resultado

O modelo desempenha um papel importante no framework da web FuelPHP. Ele representa as entidades comerciais do aplicativo. Eles são fornecidos por clientes ou buscados no banco de dados de backend, manipulados de acordo com as regras de negócios e persistidos de volta no banco de dados. Vamos aprender sobre os modelos e como eles interagem com o sistema back-end neste capítulo.

Criação de um modelo

No FuelPHP, o modelo é simplesmente uma classe PHP simples que estende a classe interna Model. Por padrão, os modelos podem ser prefixados com Model_ semelhante aos controladores e devem ser colocados emfuel/app/classes/model/pasta. Vamos criar um modelo básico de funcionário e estendê-lo à medida que avançamos.

fuel / app / classes / model / employee.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Acesse um modelo

Uma vez que um modelo é definido, ele pode ser usado livremente em qualquer controlador apenas incluindo-o no controlador como segue.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Visão geral do banco de dados

FuelPHP fornece sua própria camada de abstração de banco de dados para buscar dados do banco de dados. Ele fornece uma ferramenta baseada em ORM básica e avançada. O kit de ferramentas básico consiste em classes baseadas em DB, DBUtil e Query_Builer. O kit de ferramentas avançado é Orm. O kit de ferramentas Orm é derivado do kit de ferramentas básico e empacotado como um pacote separado.

Configuração de banco de dados

FuelPHP separa as configurações do banco de dados do arquivo de configuração principal e o arquivo é fuel/app/config/db.php. Ele suporta uma configuração separada para cada ambiente. Atualmente, o FuelPHP suporta drivers MySQL, MySQLi e PDO. A configuração de amostra é a seguinte -

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Toolkit baseado em banco de dados

o DB classé a opção mais simples para acessar o banco de dados do aplicativo. Ele fornece opções para construir a consulta do banco de dados, executá-la no banco de dados de destino e, finalmente, buscar o resultado. A classe DB interage com as classes a seguir e fornece uma API de banco de dados abrangente.

• Database_Connection - Singleton e classe principal para interagir com o banco de dados

• Database_Query - Base, classe concreta para executar a consulta SQL e buscar o resultado

• Database_Query_Builder - Base, classe abstrata para construir consulta SQL

• Database_Query_Builder_Join - Classe para construir junções SQL

• Database_Query_Builder_Where - Classe abstrata para construir condições de consulta SQL

• Database_Query_Builder_Select - Classe concreta para construir consulta SQL select

• Database_Query_Builder_Insert - Classe abstrata para construir consulta de inserção SQL

• Database_Query_Builder_Update - Classe abstrata para construir consulta de atualização SQL

• Database_Query_Builder_Delete - Classe abstrata para construir consulta de exclusão SQL

O diagrama a seguir descreve o relacionamento entre as classes e os métodos fornecidos pelas classes.

API DB

Vamos aprender os métodos mais importantes disponíveis na classe DB nesta seção.

instância

• Purpose- Cria e retorna a nova instância Database_Connection .

• Parameter -

  • $db - Nome da conexão do banco de dados definido no arquivo de configuração, opcional.

• Returns- Retorna o objeto Database_Connection

Por exemplo,

$db = DB::instance(); $db = DB::instance('test');

inquerir

• Purpose - Prepare a instrução SQL fornecida e retorna o objeto Database_Query, que pode ser usado para inserir, atualizar, excluir ou buscar os dados do banco de dados.

• Parameter -

  • $query - Instrução SQL, pode conter marcadores de posição;

  • $type - Tipo SQL, opcional (DB :: SELECT, DB :: INSERT, DB :: UPDATE e DB :: DELETE)

• Returns- Retorna o objeto Database_Query

Por exemplo,

$query = DB::query('SELECT * FROM 'employees'');

last_query

• Purpose - Para obter a última consulta executada

• Parameter - nenhum

• Returns - Retorna a última consulta executada

Por exemplo,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

selecionar

• Purpose - Gere a parte selecionada da consulta

• Parameter -

  • $columns - Lista dos nomes das colunas do banco de dados

• Returns - Retorna o objeto Database_Query_Builder_Select

Por exemplo,

$query = DB::select(); // Select * $query = DB::select('id', 'name'); // Select id, name

select_array (DB)

É semelhante ao select, exceto que podemos enviar colunas como array.

$query = DB::select_array(array('id', 'name')); // Select id, name

inserir

• Purpose - Gere a parte de inserção da consulta

• Parameter -

  • $table_name - nome da tabela do banco de dados;

  • $columns - matriz de colunas da tabela

• Returns - Retorna o objeto Database_Query_Builder_Insert

Por exemplo,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

atualizar

• Purpose - Gere a parte de atualização da consulta

• Parameter -

  • $table_name - nome da tabela do banco de dados

• Returns - Retorna o objeto Database_Query_Builder_Update

Por exemplo,

$query = DB::update('employee'); // update `employee`

excluir

• Purpose - Gere a parte de exclusão da consulta

• Parameter -

  • $table_name - nome da tabela do banco de dados

• Returns - Retorna o objeto Database_Query_Builder_Delete

Por exemplo

$query = DB::delete('employee');  // delete from 'employee'

API de consulta

Database_Queryfornece uma opção para definir a conexão do banco de dados, executar a consulta e buscar o resultado como uma matriz ou objeto associativo. Vamos ver os métodos fornecidos pela classe Database_Query.

set_connection

• Purpose - Para definir o banco de dados (detalhes de conexão do banco de dados) contra o qual executar a consulta

• Parameter - $ db - nome da conexão do banco de dados

• Returns- Retorna o objeto Database_Query

Por exemplo,

$query = DB::query('DELETE * FROM employee', DB::DELETE); $query->set_connection('2nd-db');

param

• Purpose - Para definir o valor do parâmetro definido no objeto Consulta

• Parameter -

  • $param - nome do parâmetro;

  • $value - valor do parâmetro

• Returns- Retorna o objeto Database_Query

Por exemplo,

// set some variables
$table = 'employee'; $id = 1;
$name = 'Jon'; // don't use $query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"'); // but use $query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee'); $query->param('id', $id); $query->param('name', $name);

Métodos semelhantes

parameters é um objeto semelhante, exceto que fornece a opção de fornecer vários valores de uma vez.

$query->parameters (array( 
   'tablename' => $table, 'id' => $id, 
   'name' => $name 
});

ligar

• Purpose - Para definir uma variável para o parâmetro definido no objeto Consulta

• Parameter -

  • $param - nome do parâmetro

  • $var - a variável para vincular o parâmetro

• Returns- Retorna o objeto Database_Query

Por exemplo,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); $query->bind('tablename', $table); // update the variable $table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compilar

• Purpose - Para compilar o objeto de consulta definido na consulta SQL

• Parameter -

  • $db - string de conexão, opcional

• Returns -

Por exemplo,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); $query->param('tablename', $table); // compile the query, returns: DELETE * FROM employee $sql = $query->compile();

executar

• Purpose - Executar a consulta definida no objeto Consulta e retornar o resultado

• Parameter -

  • $db - nome da conexão do banco de dados

• Returns - Retorna o resultado

Por exemplo,

// assign a value to a query parameter 
$table = 'employee'; $query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

• Purpose - Para definir o tipo de retorno como matriz associativa em vez de objetos

• Parameter - nenhum

• Returns - Retorna o objeto atual

Por exemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

como_objeto

• Purpose - Para definir o tipo de retorno como objeto em vez de matriz associativa

• Parameter - nenhum

• Returns - Retorna o objeto atual

Por exemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; } // have ORM model objects return instead $result = $query->as_object('Model_Employee')->execute();

API Query Builder

As classes baseadas no construtor de consultas (Query_Builder) fornecem opções para construir consultas SQL dinamicamente. Possui quatro classes, cada uma para selecionar (Query_Builder_Select) , inserir (Query_Builder_Insert) , atualizar (Query_Builder_Update) e excluir (Query_Builder_Delete) consultas. Essas classes são derivadas da classe Query_Builder_Where (opção para gerar condições), que por sua vez é derivada de Query_Builder , base de todas as classes.

Vejamos os métodos fornecidos pela classe Query_Builder.

selecionar

• Purpose - Para gerar as colunas de consultas selecionadas.

• Parameter -

  • $columns - lista de colunas, opcional

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name') // select `name` $query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

de

• Purpose - Para gerar os detalhes da tabela de consultas selecionadas

• Parameter -

  • $tables - lista de mesas

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee') // select `name` from `employee`

Onde

• Purpose - Para gerar as condições de selecionar, inserir e atualizar as consultas

• Parameters -

  • $column - nome da coluna ou array ($ coluna, $ alias);

  • $op - operadores lógicos, =,! =, IN, BETWEEN e LIKE, opcional;

  • $value - valor da coluna

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Métodos semelhantes

Os métodos semelhantes são where_open (), and_where_open (), or_where_open (), where_close () e_where_close (), or_where_close (). Eles são semelhantes aos métodos where (), exceto que eles adicionam palavras-chave extras e colchetes ao redor das condições. A seguir está um código de amostra.

$query = DB::select('*')->from('employee'); $query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); $query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter'); $query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

Junte-se

• Purpose - Para gerar as junções de tabelas de consultas selecionadas

• Parameters -

  • $table - nome da tabela ou array ($ table, $ alias);

  • $type - tipo de junção (LEFT, RIGHT, INNER, etc.,)

• Returns - Retorna a instância atual

Exemplo

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

em

• Purpose - Para gerar a condição de junções em consultas selecionadas

• Parameters -

  • $c1 - nome da tabela ou nome da tabela com alias no array;

  • $op - operador lógico;

  • $c2 - nome da tabela ou nome da tabela com alias na matriz

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')->join('employee_salary') $query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Métodos semelhantes

Os métodos relacionados são and_on () e or_on (). Eles são semelhantes a on (), exceto que adicionam palavras-chave extras e colchetes ao redor das junções.

group_by

• Purpose - Para gerar grupo por consultas

• Parameter - $columns - Nome da coluna pela qual agrupar o resultado

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee') $query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

tendo

• Purpose - Gerar o agrupamento por condições de consultas SQL

• Parameter - $column - nome da coluna ou matriz ( $column, $alias); $op - operadores lógicos, =,! =, IN, BETWEEN e LIKE, opcional; $value - valor da coluna

• Returns - Retorna a instância atual

Exemplo

$query = DB::select('name')->from('employee') $query = $query->group_by('name'); $query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Métodos semelhantes

Os métodos semelhantes são having_open (), and_having_open (), or_having_open (), having_close (), and_having_close (), or_having_close (). Eles são semelhantes aos métodos having (), exceto que adicionam palavras-chave extras e colchetes ao redor das condições.

Redefinir

• Purpose - Para redefinir a consulta

• Parameter - nenhum

• Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')  
$query->reset() $query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Classe DBUtil

A classe DBUtil fornece uma opção para gerenciar e executar operações de banco de dados de rotina. Alguns dos métodos importantes são os seguintes -

• set_connection - Define a conexão padrão

DBUtil::set_connection('new_database');

• create_database - Cria um banco de dados.

DBUtil::create_database('my_database');

• drop_database - Descarta um banco de dados.

DBUtil::drop_database('my_database');

• table_exists - Verifica se uma determinada tabela existe.

if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}

• drop_table - descarta uma tabela.

DBUtil::drop_table('my_table');

• create_table - cria uma tabela.

\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Orm Toolkit

FuelPHP fornece uma camada de banco de dados avançada usando o conceito ORM baseado no popular Active record pattern. O kit de ferramentas está incluído no aplicativo, mas não é configurado por padrão. Ele é empacotado como um pacote e o nome do pacote é orm. Podemos adicionar a seguinte configuração no arquivo de configuração principal,fuel/app/config/config.php para carregar o kit de ferramentas orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Criando Modelos

Orm fornece a classe de modelo base Orm \ Model. Precisamos estender nossos modelos com o modelo orm para usar os recursos ORM. A seguir está um código de amostra.

class Model_Employee extends Orm\Model {}

Configuração

Orm fornece um conjunto de configurações para configurar o modelo para usar os recursos ORM. Eles são os seguintes -

connection- Defina uma propriedade _connection estática no modelo para especificar o nome da conexão.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Defina uma propriedade _table_name estática no modelo para especificar o nome da tabela de back-end.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Defina uma propriedade _primary_key estática no modelo para especificar a chave primária da tabela de back-end.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Defina uma propriedade _properties estática no modelo para especificar as colunas da tabela de back-end. Ele suporta data_type, rótulo, validação, elementos de formulário, etc.

class Model_Employee extends Orm\Model { 
   protected static $_properties = array ( 
      'id',  
      'name' => array ( 
         'data_type' => 'varchar', 
         'label' => 'Employee Name', 
         'validation' => array ( 
            'required',  
            'min_length' => array(3),  
            'max_length' > array(80) 
         ), 
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  

      'age' => array ( 
         'data_type' => 'int', 
         'label' => 'Employee Age', 
         'validation' => array ( 
            'required',  
         ),  
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  
   ); 
}

Conditions- Defina uma propriedade _conditions estática para definir as condições e ordenar por opções.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm fornece sistema de eventos baseado em observador para adicionar comportamento a eventos específicos. Para adicionar um comportamento, primeiro defina uma propriedade _observers no modelo. Em seguida, defina o comportamento como uma classe e configure-o na propriedade _observers junto com os eventos. Se nenhum evento for especificado, o comportamento será invocado para todos os eventos. Podemos especificar comportamentos múltiplos também.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Crio

Depois de configurar o modelo, podemos começar a usar os métodos imediatamente. Orm proporciona uma economia de método para salvar o objeto no banco de dados. Podemos definir os dados usando as propriedades configuradas da seguinte maneira -

// option 1 
$new = new Model_Employee(); $new->name = 'Jon'; 
$new->save(); // option 2, use forge instead of new $new = Model_Employee::forge();
$new->name = 'Jon'; $new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); $new = Model_Employee::forge($props); $new>save();

Ler

Orm fornece um método, find para obter os dados do banco de dados e vincular ao objeto. O método find funciona dependendo do parâmetro de entrada. Vejamos as diferentes opções -

by primary key - Especificar a chave primária retorna o registro combinando a chave primária da tabela configurada.

$employee = Model_Employee::find(1);

first / last record- Especificar 'primeiro' ou 'último' irá buscar o primeiro registro ou o último registro respectivamente. Podemos passar o pedido por opção também.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Especificar 'all' buscará todos os registros da tabela configurada. Podemos especificar a ordem por opção e também por condições.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Podemos usar a API de consulta do kit de ferramentas de banco de dados básico junto com o modelo para a opção de pesquisa avançada da seguinte maneira.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Atualizar

Atualizar o modelo é o mesmo que criar, exceto que em vez de criar um novo modelo, apenas busque o modelo a ser atualizado usando o método find, atualize a propriedade e chame o método save como segue.

$entry = Model_Employee:find(4); $entry->name = 'Peter'; 
$entry->save();

Excluir

Orm fornece um método de exclusão para excluir o modelo. Basta buscar o objeto e chamar o método delete.

$entry = Model_Employee:find(4); 
$entry->delete();

Exemplo de Trabalho

Vamos criar um exemplo funcional neste capítulo para entender o modelo e o banco de dados.

Crie um banco de dados

Crie um novo banco de dados no servidor MySQL, usando o seguinte comando.

create database tutorialspoint_fueldb

Em seguida, crie uma tabela dentro do banco de dados usando o seguinte comando.

create table employee(id int primary key, name varchar(20), age int not null);

Configure o banco de dados

Vamos configurar o banco de dados usando o arquivo de configuração do banco de dados, * fuel / app / config / db.php. Adicione as seguintes alterações para conectar o servidor MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Incluir Pacote ORM

Atualize o arquivo de configuração principal, fuel/app/config/config.php para incluir o pacote ORM adicionando a seguinte configuração.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Agora, ORM está habilitado em seu aplicativo

Criar modelo de funcionário

Crie um novo modelo, Funcionário na pasta do modelo “fuel/app/classes/model”. É definido como segue.

Employee.php

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; protected static $_primary_key = array('id'); 
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Employee Name', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Criar ação

Crie uma nova ação, action_model no controlador de funcionário localizado em fuel/app/classes/controller/employee.php do seguinte modo.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production'); // orm based query to add new employees $model = new model_employee(); 
      $model->name = "john"; $model->age = 25; 
      $model->save(); $model = new model_employee(); 
      $model->name = "peter"; $model->age = 20; 
      $model->save(); // orm based query to fetch all employee data $data = array(); 
      $data['emps'] = model_employee::find('all'); return response::forge(view::forge('employee/model', $data)); 
   } 
}

Criar vista

Agora, crie um arquivo de visualização model.php localizado em “fuel/app/views/employee”. Adicione as seguintes alterações no arquivo.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Agora, solicite o URL, http://localhost:8080/employee/model e produzirá o seguinte resultado.

Resultado

FuelPHP oferece três classes, Form Fieldset,, e Input,, para realizar a programação do formulário.

• Form classe fornece uma opção para criar todos os elementos de formulários HTML.

• Fieldset classe fornece uma opção para criar elemento html por meio de métodos de nível superior, integrando os modelos e validação.

• Input A classe oferece uma opção para analisar os dados enviados por meio de formulários html, bem como parâmetros http, variáveis ​​de servidor e agentes de usuário.

Neste capítulo, vamos aprender Form programming no FuelPHP.

Formato

Conforme discutido anteriormente, a classe Form fornece métodos para criar elementos de formulário html e os métodos importantes são os seguintes -

abrir()

open()é usado para criar um novo formulário. Ele fornece os dois parâmetros a seguir -

• $attributes - atributos de tag de formulário como array ou apenas a URL de ação como string.

• $hidden - array de nome de campo oculto e seus valores.

echo Form::open('/employee/add'); 
echo Form::open(array('action' => '/employee/add', 'method' => 'post'));

Fechar()

close() simplesmente fecha o formulário.

echo Form::close();

entrada()

input()cria o elemento de entrada html. Ele tem os três parâmetros a seguir,

• $field - nome do elemento de entrada

• $value - valor do elemento de entrada

• $attributes - atributos do elemento de entrada como matriz

echo Form::input('name', 'jon', array('style' => 'border: 20px;'));

elemento de etiqueta

labelcria um elemento de rótulo html. Ele tem os três parâmetros a seguir,

• $label - etiqueta para mostrar

• $id - ID de elemento de formulário associado

• $attributes - atributos do elemento label como array

echo Form::label('Employee Name', 'employee_name');

escondido

hidden é semelhante ao método de entrada, exceto que define o tipo do elemento de entrada como oculto.

senha

password é semelhante ao método de entrada, exceto que define o tipo do elemento de entrada como senha.

rádio

radioé semelhante ao método de entrada, exceto que define o tipo do elemento de entrada para rádio. Ele tem os quatro parâmetros a seguir,

• $field - nome do elemento de entrada

• $value - valor do elemento de entrada

• $checked - se o item é verificado ou não (verdadeiro / falso)

• $attributes - atributos do elemento de entrada como matriz

echo Form::label('Male', 'gender'); 
echo Form::radio('gender', 'Male', true); 
echo Form::label('Female', 'gender'); 
echo Form::radio('gender', 'Female');

caixa de seleção

checkboxé semelhante ao método de entrada, exceto que define o tipo do elemento de entrada como caixa de seleção. Ele tem os quatro parâmetros a seguir,

• $field - nome do elemento de entrada

• $value - valor do elemento de entrada

• $checked - se o item é verificado ou não (verdadeiro / falso)

• $attributes - atributos do elemento de entrada como matriz

echo Form::label('Male', 'gender'); 
echo Form::checkbox('gender', 'Male', true);
echo Form::label('Female', 'gender'); 
echo Form::checkbox('gender', 'Female');

Arquivo

file é semelhante ao método de entrada, exceto que define o tipo do elemento de entrada para arquivo.

área de texto

textareacria o elemento textarea html. Ele tem os três parâmetros a seguir,

• $field - nome do elemento textarea

• $value - valor do elemento textarea

• $attributes - atributos do elemento textarea como array

echo Form::textarea ('description', 'original data (value)', array ('rows' => 6, 
      'cols' => 8));

selecionar

selectcria um elemento de seleção HTML. Ele tem os seguintes quatro parâmetros -

• $field - nome do elemento selecionado

• $values - valores de seleção inicial

• $options- opções como array. As opções podem ser agrupadas usando uma matriz aninhada

• $attributes - atributos do elemento de entrada como matriz

echo Form::select ( 
   'country',  
   'none',  
   array ( 
      'none'  => 'None', 
      'asia'  => array ( 
         'in' > 'India', 
         'cn' => 'China' 
      ), 
      
      'us' => 'United States' 
   ) 
);

enviar

submit é semelhante ao método de entrada, exceto que define o tipo do elemento de entrada a ser enviado.

botão

buttoncria um elemento de botão html. Ele tem os três parâmetros a seguir,

• $field - nome do elemento do botão

• $value - valor do elemento do botão

• $attributes - atributos do elemento do botão como matriz

echo Form::button('emp_submit', 'Submit');

Redefinir

reset é semelhante ao método de entrada, exceto que define o tipo do elemento de entrada para redefinir.

fieldset_open

fieldset_open cria conjunto de campos html e elementos de legenda. Ele tem os seguintes dois parâmetros -

• attributes - atributos do elemento fieldset como array

• legend - nome da legenda a ser criada

// returns <fieldset class = "example-class" id = "example-id">
<legend>
   Custom Legend
</legend> 

echo Form::fieldset_open (array (
   'class'  => 'example-class', 
   'id'     => 'exampleid', 
   'legend' => 'Custom Legend'
));

fieldset_close

fieldset_close cria a tag de fechamento do conjunto de campos HTML.

// returns </fieldset> 
echo Form::fieldset_close();

Classe de entrada

A classe de entrada fornece métodos para ler todos os dados da solicitação junto com os detalhes do formulário. Alguns dos métodos importantes são os seguintes -

uri

uri retorna o URI atual da solicitação

// request: http://localhost:8080/employee/welcome  
echo Input::uri(); // return /employee/welcome

método

method retorna o método HTTP usado na solicitação

echo Input::method() // "POST"

pegue

getpermite ler variáveis ​​$ _GET. Ele tem os dois parâmetros a seguir,

• $index - índice da matriz $ _GET

• $default - valor padrão, se o índice não for encontrado.

echo Input::get('age', '20'); // returns $_GET['age']

postar

postpermite ler variáveis ​​$ _POST. Ele tem os dois parâmetros a seguir,

• $index - índice da matriz $ _POST

• $default - valor padrão, se o índice não for encontrado

echo Input::get('age', '20'); // returns $_POST['age']

param

param permite buscar o item de $ _GET, $_POST, $_PUT ou variáveis ​​$ _DELETE. Ele tem os dois parâmetros a seguir,

• $index - índice da matriz

• $default - valor padrão, se o índice não for encontrado

Se nenhum parâmetro for especificado, ele retornará todos os itens.

echo Input::param('age', '20'); // returns $_POST['age']

Arquivo

filepermite ler variáveis ​​$ _FILE. Ele tem os dois parâmetros a seguir,

• $index - índice da matriz $ _POST

• $default - valor padrão, se o índice não for encontrado

echo Input::file();

is_ajax

is_ajax retorna verdadeiro, se a solicitação for feita por meio de AJAX.

echo Input::is_ajax() // return false

protocolo

protocol retorna o protocolo HTTP usado na solicitação.

echo Input::protocol() // returns "HTTP"

ip

ip retorna o endereço IP por meio do qual a solicitação é feita.

echo Input::ip() // returns "84.45.34.24" (Public IP Address)

real_ip

real_ip tenta retornar o endereço IP real (se o cliente estiver atrás de proxy) por meio do qual a solicitação é feita.

echo Input::real_ip() // returns "10.76.12.1" (local private IP Address)

servidor

serverpermite ler variáveis ​​$ _SERVER. Ele tem os dois parâmetros a seguir,

• $index - índice da matriz $ _POST

• $default - valor padrão, se o índice não for encontrado.

echo Input::server('HTTP_HOST'); // returns localhost:8080

referenciador

referrerretorna o referenciador da variável $ _SERVER. É um método de atalho para obter o referenciador http da solicitação atual.

agente de usuário

user_agentretorna o agente do usuário da variável $ _SERVER. É um método de atalho para obter o agente do usuário http da solicitação atual.

query_string

query_stringretorna a string de consulta da variável $ _SERVER. É um método de atalho para obter a string de consulta da solicitação atual.

cabeçalhos

headersretornar o cabeçalho específico ou todos os cabeçalhos. Ele tem os seguintes dois parâmetros -

• $index - nome dos cabeçalhos HTTP

• $default - valor padrão, se o índice não for encontrado.

echo Input::headers('Content-Type'); // returns "text/html"

extensão

extension retorna a extensão URI da solicitação atual.

// Example URL: http://localhost/test/ 
echo Input::extension();  // NULL  

// Example URL: http://localhost/test.html 
echo Input::extension();  // 'html'

Exemplo de Trabalho

Vamos criar um formulário simples para adicionar novos funcionários usando as classes Form e Input.

Criar formulário

Crie uma nova ação, get_add no controlador de funcionários da seguinte forma.

public function get_add() { 
   return Response::forge(View::forge('employee/add')); 
}

Agora, adicione a visão para a ação, fuel / app / views / employee / add.php como segue.

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <title>Employee :: add page</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <?php echo Asset::css('bootstrap.css'); ?> 
   </head>
   
   <body> 
      <div class = "container"> 
         <?php 
            echo Form::open(array('action' => 'employee/add', 'method' => 'post')); 
         ?>  
         
         <div class = "form-group"> 
            <?php 
               echo Form::label('Employee name:', 'name'); 
               echo Form::input('name', '', array('class' => 'form-control')); 
            ?> 
         </div> 
         
         <div class = "form-group"> 
            <?php 
               echo Form::label('Employee age:', 'age'); 
               echo Form::input('age', '', array('class' => 'form-control')); 
            ?> 
         </div> 
         
         <?php echo Form::button('frmbutton', 'Submit', array(
            'class' => 'btn btn-default')); 
         ?> 
         
         <?php 
            echo Form::close(); 
         ?> 
      </div> 
   </body> 
   
</html>

Aqui, nós usamos bootstrappara projetar o formulário. FuelPHP fornece suporte completo para componentes de bootstrap. Agora, solicitando a página, http: // localhost: 8080 / employee / add mostrará o seguinte formulário.

Formulário de Processo

Crie uma nova ação, post_add para processar o formulário e adicionar os dados do funcionário inseridos pelo usuário no banco de dados no controlador do funcionário como segue.

public function post_add() { 
   $name = Input::post('name'); 
   $age = Input::post('age'); $model = new model_employee(); 
   $model->name = $name; 
   $model->age = $age; 
   $model->save();  
   Response::redirect('employee/list'); 
}

Aqui, fomos redirecionados para a página da lista de funcionários, uma vez que os dados inseridos do usuário são salvos no banco de dados. A seguir, criaremos a página da lista de funcionários.

Funcionário da lista

Crie uma nova ação, action_list para listar o funcionário no banco de dados como segue.

public function action_list() { 
   $data = array(); 
   $data['emps'] = model_employee::find('all'); return Response::forge(view::forge('employee/list', $data)); 
}

Crie uma nova vista, fuel/app/views/employee/list para a ação acima como segue.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   <?php 
   } 
   ?> 
</ul>

Verifique o Formulário

Agora, solicite o URL, http://localhost:8080/employee/add, insira alguns dados do funcionário conforme mostrado na captura de tela a seguir e envie o formulário.

Em seguida, mostra todos os funcionários (incluindo um recém-adicionado) disponíveis no banco de dados da seguinte forma -

Validationé uma das tarefas frequentes e mais repetidas em um aplicativo da web. O usuário insere os dados necessários no formulário e os envia. Em seguida, o aplicativo da web precisa validar os dados antes de processá-los. Por exemplo, o usuário insere os dados do funcionário e a post_action precisa ser validada antes de salvá-la no banco de dados. O FuelPHP fornece uma classe realmente simples, Validation, para esse propósito.

No FuelPHP, o conceito de validação é muito simples e fornece vários métodos através da classe Validation para validar adequadamente o formulário. A seguir está o fluxo de trabalho da validação,

Step 1 - Crie um novo objeto de validação usando forge método.

$val = Validation::forge();

Step 2 - Adicione os campos que precisam ser validados usando o método add.

$val->add('name', 'Employee name');

Step 3 - Defina as regras de validação para os campos adicionados usando add_rule método.

$val->add('name', 'Employee name')->add_rule('required'); 
$val->add('age', 'Employee age')->add_rule('required') 
   ->add_rule('numeric_min', 20) 
   ->add_rule('numeric_max', 30);

Step 4 - Chame o método run para validar os dados.

// run validation on just post 
if ($val->run()) { 
   // success 
} else { 
   // falier 
}

Step 5 - Use validado e erro para obter os campos válidos e inválidos, respectivamente.

$vars = $val->validated(); 
$vars = $val->error();

Regras

FuelPHP contém muitas regras para validar e também fornece uma opção para criar novas regras. As regras suportadas pela classe de validação são as seguintes,

• required - Valor a ser inserido

• required_with- Defina outro campo como campo complementar. Se o campo estiver definido, os campos complementares também precisam ser definidos

• match_value - Defina o valor a ser combinado com o valor do campo

• match_pattern - Defina o valor a ser correspondido como uma expressão regular com o valor do campo

• match_field - Defina o valor de outro campo como valor a ser combinado com o valor do campo

• match_collection - Defina o valor a ser correspondido como coleção com o valor do campo

• min_length - Defina o comprimento mínimo do valor do campo

• max_length - Defina o comprimento máximo do valor do campo

• exact_length - Defina o comprimento exato do valor do campo

• valid_date - Defina o valor do campo para uma data válida

• valid_email - Defina o valor do campo como um e-mail válido

• valid_emails - Defina o valor do campo para e-mails válidos, separados por vírgula

• valid_url - Defina o valor do campo para um URL válido

• valid_ip - Defina o valor do campo para um IP válido

• numeric_min - Defina o valor mínimo do valor do campo

• numeric_max - Defina o valor máximo do valor do campo

• numeric_between - Defina o valor mínimo e máximo do valor do campo

• valid_string - Semelhante ao regex, mas mais simples

$val->add('username', 'User name')->add_rule('valid_string', array('alpha, dots');

Aqui, alfa se refere a caracteres alfabéticos e os pontos se referem a (.). A string válida é apenas a string que contém o caractere alfabético e (.). As outras opções são maiúsculas, minúsculas, especiais, numéricos, espaços, etc.

Exemplo de Trabalho

Podemos atualizar o recurso de adicionar funcionário para incluir a validação. Basta atualizar opost_add método do controlador de funcionário como segue.

public function post_add() { 
   $val = Validation::forge(); 
   $val->add('name', 'Employee name')->add_rule('required'); $val->add('age', 'Employee age')->add_rule('required')
      ->add_rule('numeric_min', 20) 
      ->add_rule('numeric_max', 30);  
   
   if ($val->run()) { $name = Input::post('name'); 
      $age = Input::post('age'); $model = new model_employee(); 
      $model->name = $name; 
      $model->age = $age; 
      $model->save();  
      Response::redirect('employee/list'); 
   } else { 
      Response::redirect('employee/add'); 
   } 
}

Aqui, especificamos o namee idade como campos obrigatórios. oagedeve estar entre 20 e 30. Se ambas as regras forem válidas, os dados do funcionário serão salvos e redirecionados para a página da lista de funcionários. Caso contrário, os dados do funcionário serão rejeitados e redirecionados para adicionar a página do funcionário.

FuelPHP fornece uma programação avançada de formulário por meio das classes Fieldset e Fieldset_Field. Fieldsetfornece uma maneira orientada a objetos para criar um formulário. Possui suporte completo para modelos. Tem suporte integrado para validação do lado do cliente e do lado do servidor também. Para criar um formulário completo, é suficiente criar um modelo com formulário e configuração de validação adequados. Vamos aprender sobre a classe Fieldset e como criar um formulário usando-a neste capítulo.

Fieldset

Fieldset é uma coleção de Fieldset_Fieldobjetos. Fieldset_Field define a entrada individual de um formulário, como nome, sobrenome, etc. junto com as validações. A classe Fieldset possui métodos para adicionar / editar / remover campos. Possui opções para identificar os campos definidos em um modelo e criar os campos a partir do modelo fornecido.Fieldsetusa classes Form e Validation em segundo plano para fazer o trabalho real. Vejamos alguns dos métodos importantes da classe Fieldset.

forja

forgecria uma nova instância Fieldset. Ele tem os seguintes dois parâmetros -

• $name - identificador para o fieldset

• $config- array de configuração. As opções possíveis são validation_instance e form_instance. validation_instance pode ter Validação objeto e form_instance pode ter objeto Form.

$employee_form = Fieldset::forge('employee');

instância

instance retorna a instância Fieldset criada anteriormente por identificador.

$employee_form = Fieldset::instance('employee');

get_name

Obtém o identificador da instância fieldset.

$employee_form = Fieldset::forge('employee'); 
$name = $employee_form->get_name();

adicionar

addcria uma nova instância Fieldset_Field e a adiciona ao fieldset atual. Ele contém os quatro parâmetros a seguir,

• $name - nome do campo

• $label - rótulo para o campo

• $attributes - atributos de tag HTML

• $rules - regras de validação

$employee_field = $employee_form-> add (
   'employee_lastname', 
   'Lastname', 
   array ('class' => 'pretty_input')
);  

// with validation rules 
$employee_form->add ( 
   'email', 'E-mail', 
   array('type' => 'email', 'class' => 'pretty_input'), 
   array('required', 'valid_email') 
);

acrescentar antes

add_before é semelhante a add, exceto por ter um parâmetro extra para especificar o campo antes do qual o campo recém-criado será adicionado.

$employee_form->add_before (
   'employee_firstname', 
   'Firstname', 
   array ('class' => 'pretty_input'), 
   array(), 
   'employee_lastname'
);

excluir

delete exclui o campo especificado do fieldset.

$employee_form->delete('employee_firstname');

campo

field obtém todos os campos ou o especificado no fieldset.

$fields = $employee_form->field(); $lastname_field = $employee_form->field('employee_lastname');

Construir

buildé um apelido para $ this-> form () -> build () . Gera a marcação HTML do formulário.

$employee_form->build(Uri::create('employee/add'));

habilitar

enable reativa um campo que foi desativado anteriormente.

$employee_form->enable('employee_firstname');

desabilitar

disable permite desativar a construção de um campo no conjunto de campos.

$employee_form->disable('employee_firstname');

Formato

form retorna a instância de Form do fieldset atual.

$form = employee_form->form();

add_model

add_model adiciona o campo do modelo ao fieldset. Ele tem os três parâmetros a seguir,

• $class - nome da classe

• $instance - instância da classe para preencher os campos com valor

• $method- nome do método na classe. Este método é usado para adicionar campos ao fieldset. Orm \ Model tem o método necessário. O nome do método padrão é set_form_fields.

$employee_form = Fieldset::forge('employee'); 
$employee_form->add_model('Model_Employee');

povoar

populate define o valor inicial dos campos em fieldset usando instância de modelo.

$emp = new Model_Employee(); 
$emp->name = "Jon"; $employee_form->populate($emp);

repovoar

repopulate é o mesmo que preencher, exceto que preenche novamente os campos no conjunto de campos.

validação

validation obtém a instância de validação do fieldset atual.

$validation = $employee_form->validation();

validado

Alias ​​para $ this-> validation () -> validated ().

input

Alias ​​para $ this-> validation () -> input ().

error

Alias ​​para $ this-> validation () -> error ().

show_errors

Alias ​​para $ this-> validation () -> show_errors ().

Exemplo de Trabalho

Vamos criar um formulário avançado para adicionar novos funcionários em nosso aplicativo de amostra de funcionários usando a classe Fieldset.

Atualizar modelo

Atualize o modelo de funcionário com as regras de validação necessárias e adicione um observador de validação como segue.

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; protected static $_primary_key = array('id'); 
      
      protected static $_properties = array ( 'id', 'name' => array ( 'data_type' => 'varchar', 'label' => 'Employee Name', 'validation' => array ( 'required', 'min_length' => array(3), 'max_length' => array(80) ), 'form' => array ( 'type' => 'text' ), ), 'age' => array ( 'data_type' => 'int', 'label' => 'Employee Age', 'validation' => array ( 'required', ), 'form' => array ('type' => 'text' ), ), ); // Just add the Observer, and define the required event protected static $_observers = array('Orm\\Observer_Validation' => array ( 
         'events' => array('before_save'))); 
   }

Aqui, definimos as regras de validação para os campos de nome e idade e adicionamos um novo observador para realizar a validação do lado do servidor antes de salvar o modelo no banco de dados. A mesma regra de validação criará atributos de validação de entrada necessários também no formulário.

Criar formulário

Crie uma nova ação, action_advancedform no controlador de funcionário como segue.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee'); // get form from fieldset $form = $fieldset->form(); // add submit button to the form $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));  
   
   // build the form  and set the current page as action  
   $formHtml = $fieldset->build(Uri::create('employee/advancedform'));  
   
   // set form in data 
   $data = array(); $data['form'] = $formHtml; return Response::forge(View::forge('employee/advancedform', $data, false)); 
}

Aqui, criamos o formulário usando fieldset e enviamos o formulário para a visualização. Em seguida, adicione uma visão para a ação,fuel/app/views/employee/advancedform.php do seguinte modo.

<!DOCTYPE html> 
<html lang = "en"> 
   
   <head> 
      <title>Employee :: add page</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <?php echo Asset::css('bootstrap.css'); ?> 
      
      <style>  
         table { 
            width: 90%; 
         }  
         table tr { 
            width: 90% 
         }
         table tr td { 
            width: 50% 
         }  
         input[type = text], select { 
            width: 100%; 
            padding: 12px 20px; 
            margin: 8px 0; 
            display: inline-block; 
            border: 1px solid #ccc; 
            border-radius: 4px; 
            box-sizing: border-box; 
         }  
         input[type = submit] { 
            width: 100%; 
            background-color: #3c3c3c; 
            color: white; 
            padding: 14px 20px; 
            margin: 8px 0; 
            border: none; 
            border-radius: 4px; 
            cursor: pointer; 
         }  
         div { 
            border-radius: 5px; 
            background-color: #f2f2f2; 
            padding: 20px; 
         } 
      </style> 
   </head> 
   
   <body> 
      <div class = "container"> 
         <?php
            if(isset($errors)) { echo $errors; 
            } 
            echo $form; 
         ?> 
      </div> 
   </body> 
   
</html>

Agora, solicitando a página http://localhost:8080/employee/add irá mostrar o seguinte formulário.

Formulário de Processo

Atualize o método de ação, action_advancedform para processar o formulário e adicionar os dados do funcionário inseridos pelo usuário no banco de dados no controlador de funcionário da seguinte maneira.

public function action_advancedform() { 
   
   // create a new fieldset and add employee model 
   $fieldset = Fieldset::forge('employee')->add_model('Model_Employee');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('employee/advancedform')); if (Input::param() != array()) { try { $article = Model_Employee::forge(); 
         $article->name = Input::param('name'); $article->url = Input::param('age'); 
         $article->save(); Response::redirect('employee/list'); } catch (Orm\ValidationFailed $e) { 
         $view = View::forge('employee/advancedform'); $view->set('form', $formHtml, false); $view->set('errors', $e->getMessage(), false); } } return Response::forge($view); 
}

Aqui, fomos redirecionados para a página da lista de funcionários, uma vez que os dados inseridos pelo usuário são validados e salvos no banco de dados. Caso contrário, o formulário será mostrado novamente.

Crie o formulário

Agora, solicite o URL, http://localhost:8080/employee/adde insira alguns dados do funcionário e envie o formulário. Se os dados não forem fornecidos, o formulário solicitará que o usuário insira os dados conforme mostrado na captura de tela a seguir.

Se o usuário ignorar a validação do lado do cliente, o servidor validará o formulário e mostrará um erro, conforme mostrado na captura de tela a seguir.

Se os dados forem aprovados na validação do lado do cliente e do servidor, os dados do funcionário serão salvos no banco de dados e a página será redirecionada para a página de lista.

O upload de arquivos é um dos recursos mais usados ​​na programação de formulários. FuelPHP oferece uma classe especial,Uploadpara lidar com o upload de arquivos. Vamos aprender como fazer upload de um arquivo usando a classe Upload neste capítulo.

Configuração

A classe de upload pode ser configurada usando um arquivo de configuração separado, fuel/app/config/upload.php. As entradas de configuração importantes são as seguintes -

• max_size- Defina o tamanho máximo do arquivo a ser carregado. “0” refere-se ao tamanho de upload ilimitado

• ext_whitelist - Definir extensões de arquivo permitidas

• ext_blacklist - Definir extensões de arquivo não permitidas

• type_whitelist- Defina os tipos de arquivo permitidos. Por exemplo, “texto” para tipo MIME “texto / simples”

• type_blacklist - Definir tipos de arquivo não permitidos

• mime_whitelist- Defina os tipos de arquivo MIME permitidos. Por exemplo, “texto / simples”

• mime_blacklist - Definir tipos de arquivo MIME não permitidos

• prefix - String para prefixar no nome do arquivo ao salvar o arquivo carregado no servidor

• suffix - String para sufixo no nome do arquivo ao salvar o arquivo enviado para o servidor

• extension - Extensão do arquivo enviado a ser definido

• create_path - Se deve criar o caminho do arquivo, se não estiver disponível

• overwrite - Substituir o arquivo existente ao salvar o arquivo carregado

• auto_rename - Se deve renomear o arquivo adicionando um número de sequência enquanto salva o arquivo carregado

• randomize - Se deve criar um nome aleatório de 32 caracteres para salvar o arquivo enviado

Métodos de upload

A classe de upload oferece opções para processar e salvar o arquivo carregado pelos usuários. Cada arquivo processado (antes de salvar) terá as seguintes informações na matriz de resultado.

• field - Nome do campo do formulário

• name - Nome do arquivo enviado

• type - Tipo de arquivo conforme definido pelo navegador

• mimetype - Tipo de arquivo conforme definido pela classe Upload

• file - Nome totalmente qualificado da localização temporária do arquivo carregado

• filename - Nome do arquivo enviado

• extension - Extensão do arquivo enviado

• size - Tamanho do arquivo enviado em bytes

• errors - Matriz de erro com código e mensagem de erro

• error - Definir erros de array explicando por que o upload falha (em caso de falha no upload)

Assim que os arquivos forem salvos no servidor, a matriz de resultados também terá as seguintes informações.

• saved_to - Caminho totalmente qualificado onde o arquivo enviado foi salvo

• saved_as - Nome do arquivo que foi salvo

• errors - Matriz de erro atualizada

Agora, vamos ver o método da classe Upload.

é válido

is_valid retorna verdadeiro, se qualquer arquivo válido for carregado pelo usuário.

// do we have any uploaded files to save? 
if (Upload::is_valid()) { 
   // process  
}

get_files

get_files retorna todos os arquivos carregados como um array multidimensional. Se um índice / nome da entrada de arquivo do formulário for especificado, ele retornará o arquivo carregado relacionado apenas à entrada de arquivo especificada.

foreach(Upload::get_files() as $file) { 
   // do something with the file info 
}  
if ( Upload::get_files(0)) { 
   // do something 
}

get_errors

get_errors retorna uma matriz de erros, se houver uma falha no upload de um ou mais arquivos. Se um índice / nome do nome de entrada do arquivo do formulário for especificado, ele retornará o erro relacionado apenas à entrada do arquivo especificado.

foreach(Upload::get_errors() as $file) { 
   // do something with the file info 
}  
if (Upload::get_errors('myimage')) { 
   // do something 
}

Processo

processo refere-se ao processo real de coleta de informações sobre o arquivo carregado. Podemos fornecer uma nova configuração personalizada usando array. Se nenhuma configuração for especificada, ele usará a configuração definida em fuel / app / config / upload.php

Upload::process (array( 
   'auto_rename' => false, 
   'overwrite'   => true 
));

Salve 

salvar refere-se ao processo real de salvar todos os arquivos validados em um local apropriado. Podemos especificar o índice para salvar apenas essa entrada particular.

Upload::save();
Upload::save(0);
Upload::save(0, 3);

Exemplo de Trabalho

Vamos criar um novo controlador, Controller_Upload em nosso exemplo de funcionário para testar a funcionalidade de upload.

Step 1 - Crie um arquivo, fuel/app/classes/controller/upload.php. Crie um controlador de upload.

<?php 
   class Controller_Upload extends Controller { 
   }

Step 2 - Crie uma nova ação get_upload.

<?php  
   class Controller_Upload extends Controller { 
      public function get_index() { 
         return \View::forge("upload/index"); 
      } 
   }

Step 3 - Crie uma nova visão para a ação criada.

<!DOCTYPE html> 
<html> 
   <body> 
   
      <form action = "/upload/index" method = "post" enctype = "multipart/form-data"> 
         Select image to upload: 
         <input type = "file" name = "fileToUpload" id = "fileToUpload"> 
         <input type = "submit" value = "Upload Image" name = "submit"> 
      </form>  
      
   </body> 
</html>

Step 4 - Crie uma nova ação post_action para processar o arquivo carregado.

<?php  
   class Controller_Upload extends Controller { 
      public function get_index() { 
         return \View::forge("upload/index"); 
      }  
      public function post_index(){ 
         $config = array( 'path' => DOCROOT.'files', 'randomize' => true, 'ext_whitelist' => array('img', 'jpg', 'jpeg', 'gif', 'png'), ); Upload::process($config);  
         // if there are any valid files 
         
         if (Upload::is_valid()) { 
            Upload::save(); 
            echo "success"; 
         } else { 
            // and process any errors 
            foreach (Upload::get_errors() as $file) { echo var_dump($file); 
            } 
         } 
      } 
   }

Por fim, execute o aplicativo solicitando o url, http://localhost:8080/upload/index e tente fazer upload do arquivo.

Resultado

AJAX é uma tecnologia moderna em programação web. Ele fornece opções para enviar e receber dados em uma página da Web de forma assíncrona, sem atualizar a página. Vamos aprender sobre a programação FuelPHP AJAX neste capítulo.

A estrutura FuelPHP fornece opções para identificar se o tipo de solicitação é AJAX ou não. A classe de entrada tem um método,is_ajax()para este propósito. Se uma solicitação AJAX for feita,Input::is_ajax método retorna true, de outra forma false.

Este método é usado para tratar uma solicitação AJAX corretamente no lado do servidor.

if (Input::is_ajax()) {  
   // Ajax request  
} else {  
   // Normal request  
}

Podemos usar json_encodepara retornar a resposta JSON. Podemos combinar esses dois métodos para criar um aplicativo da web baseado em AJAX simples e limpo.

Exemplo de Trabalho

Vamos adicionar uma nova página, ajax/index no aplicativo do funcionário e tente buscar as informações do funcionário de forma assíncrona.

Step 1 - Crie um novo controlador, Controller_Ajax em fuel / app / classes / controller / ajax.php.

<?php  
   class Controller_Ajax extends Controller { 
   }

Step 2- Crie uma nova ação, action_index da seguinte maneira.

<?php  
   class Controller_Ajax extends Controller { 
      public function action_index() { 
         $emps = model_employee::find('all'); $data = array(); 
         $i = 0; foreach($emps as $emp) { $data[$i] = array(); $data[$i]['name'] = $emp['name']; 
            $data[$i]['age'] = $emp['age']; $i = $i + 1; } if(\Input::is_ajax()) { echo json_encode($data); 
         } else { 
            return \View::forge("ajax/index"); 
         } 
      } 
   }

Aqui, se a solicitação for AJAX, buscamos as informações do aluno, codificamos como JSON e as retornamos. Caso contrário, apenas renderizaremos a visualização correspondente.

Step 3 - Crie o arquivo de visualização correspondente, fuel/app/views/ajax/index.php do seguinte modo.

<html>
   <head>
      <script language = "javascript" src = "/assets/js/jquery-3.2.1.min.js"></script>
      
      <style>
         .table { border-collapse: collapse; }
         .table th, td {
            border-bottom: 1px solid #ddd;
            width: 250px;
            text-align: left;
            align: left;
         }
      </style>
   </head>
   
   <body>
      <a id = "loademployee" href = "#">Load employee information</a>
      </br> 
      </br>

      <table class = "table">
         <tbody id = "employee">
         </tbody>
      </table>
      
      <script language = "javascript">
         $(document).ready(function() { $("#loademployee").on("click", function(event) {
               $.ajax ({ url: '/ajax/index', type: 'POST', dataType: 'json', async: true, success: function(data, status) { var e = $('<tr><th>Name</th><th>Age</th></tr>');
                     $('#employee').html(''); $('#employee').append(e);
                     
                     for(i = 0; i < data.length; i++) {
                        employee = data[i];
                        var e = $('<tr><td id = "name"></td><td id = "age"></td></tr>'); $('#name', e).html(employee['name']);
                        $('#age', e).html(employee['age']); $('#employee').append(e);
                     }
                  },
                  
                  error : function(xhr, textStatus, errorThrown) {
                     alert('Ajax request failed.');
                  }
               });
            });  
         });
      </script>
   </body>
   
</html>

Aqui, criamos uma tag âncora (id: loademployee) para carregar as informações do funcionário usando a chamada AJAX. A chamada AJAX é feita usando JQuery. O evento anexado à tag loademployee é ativado quando um usuário clica nele. Em seguida, ele buscará as informações do funcionário usando a chamada AJAX e gerará o código HTML necessário de forma dinâmica.

Step 4 - Execute o aplicativo.

Por fim, execute o aplicativo, http://localhost:8000/ajax/index e clique na guia Carregar âncora de informações do funcionário.

Resultado

FuelPHP fornece um excelente recurso para solicitar uma ação dentro do mesmo aplicativo usando Requestclasse. Isso é chamado de Solicitação HMVC. Permite reutilizar a lógica do controlador.

Criação de uma solicitação HMVC

Criar uma solicitação HMVC é tão simples quanto criar um objeto de solicitação com a URL necessária e chamar o método execute da seguinte maneira.

$list = Request::forge('employee/list/')->execute(); echo $list;  

$employee = Request::forge('employee/show/1')->execute(array('id' => '1')); echo $employee;

Exemplo de Trabalho

Vamos criar um novo controlador, Controller_HMVC para testar o recurso HMVC. Crie um arquivo,fuel/app/classes/controller/hmvc.php e coloque o seguinte código.

<?php 
   class Controller_HMVC extends Controller { 
      public function action_index() { 
         echo Request::forge('employee/list')->execute(); 
      } 
   }

Aqui, acabamos de chamar a página de funcionário / lista por meio da solicitação HMVC e mostramos o resultado.

Resultado

Os temas são usados ​​para permitir a aparência e o comportamento do aplicativo. Ele fornece a opção para o usuário / desenvolvedor alterar a aparência e comportamento do aplicativo sem perturbar a funcionalidade do aplicativo. Um aplicativo pode ter um ou mais temas. Cada tema reside em sua própria pasta. Vamos aprender como criar temas neste capítulo.

Configuração do Tema

FuelPHP fornece um arquivo de configuração separado para temas, fuel/app/config/themes.php. Todas as configurações relacionadas ao tema são definidas neste arquivo. Algumas das configurações do tema principal são as seguintes -

• active - Nome do tema ativo

• fallback - Nome do tema substituto, se o tema ativo não for encontrado

• paths - Matriz do caminho para pesquisar e encontrar temas

• assets_folder- Normalmente, os ativos precisam estar dentro do DOCPATH para que possam ser acessados ​​pela web. Refere-se à pasta de ativos para os temas dentro do DOCPATH

• view_ext - Extensão do arquivo de visualização do tema

• info_file_name - Arquivo com informações estendidas sobre temas

• require_info_file - Se é necessário o arquivo de informações do tema, info_file_name

• use_modules - Se usar o módulo atual ou não

A configuração simples para o arquivo de tema é a seguinte.

<?php  
   return array ( 
      'active' => 'tpthemes', 
      'fallback' => 'tpthemes', 
      'paths' => array ( 
         APPPATH.'themes', 
      ), 
      'assets_folder' => 'assets', 
      'view_ext' => '.html', 
      'require_info_file' => false, 
      'info_file_name' => 'themeinfo.php', 
      'use_modules' => false, 
   );

Aqui nós definimos,

• O nome do tema ativo e substituto como tpthemes
• O caminho da pasta do tema como combustível / app / temas /
• O caminho da pasta de ativos como / public / assets / tpthemes /

Aula temática

Uma vez feita a configuração, podemos usar a classe Tema fornecida pelo FuelPHP para fazer a funcionalidade do tema. Informe-nos sobre os métodos disponíveis na classe Theme neste capítulo.

instância

método de instância permite criar um novo tema. Ele tem os dois parâmetros a seguir,

• $name - Nome do tema (opcional)

• $config - Matriz de configuração do tema (o mesmo visto na seção de configuração)

Ambos os parâmetros são opcionais. Se nenhum parâmetro for especificado, ele tenta obter o tema padrão do arquivo de configuração. Se o nome do tema for especificado, ele tenta obter as outras configurações do arquivo de configuração. Se a configuração também for especificada, ela usará a configuração especificada pelo usuário em vez da configuração do arquivo de configuração.

$theme = \Theme::instance(); $theme = \Theme::instance('tpthemes'); 
$theme = \Theme::instance ('mytheme', array ( 
   'active' => 'mytheme', 'view_ext' => '.php'));

forja

forge é semelhante a instance, exceto que só tem array de configuração.

$theme = \Theme::forge (array( 
   'active'   => 'tpthemes', 
   'fallback' => 'tpthemes', 
   'view_ext' => '.php', 
));

Visão

método de visualização usa o View::forge()no fundo. Ambas as APIs são semelhantes, exceto pelo método de visualização que procura o arquivo de visualização na pasta de temas, fuel / app / themes / tpthemes / em vez de fuel / app / views / pasta.

$theme = \Theme::instance(); $view = $theme->view('template/index'); 
// *fuel/app/themes/tpthemes/template/index.php

apresentador

método do apresentador usa o Presenter::forge()no fundo. Ambas as APIs são semelhantes, exceto pelo método do apresentador que procura o arquivo de visualização na pasta de temas, fuel / app / themes / tpthemes / em vez de fuel / app / views / pasta.

$theme = \Theme::instance(); 
$presenter = $theme->presenter('template/index');

asset_path

O método asset_path retorna o caminho para o ativo solicitado em relação ao tema atualmente selecionado.

$theme = \Theme::instance(); // public/assets/tpthemes/css/style.css $style = \Html::css($theme->asset_path('css/style.css'));

add_path

O método add_path permite adicionar um caminho de tema em tempo de execução.

$theme = \Theme::instance(); 
$theme->add_path(DOCROOT.'newthemes');

add_paths

O método add_paths permite adicionar vários caminhos de tema em tempo de execução.

$theme = \Theme::instance();   
$theme->add_path(DOCROOT.'newthemes');

ativo

método ativo permite definir o tema ativo.

$theme = \Theme::instance(); 
$active = $theme->active('newtheme');

cair pra trás

o método de fallback permite definir o tema de fallback.

$theme = \Theme::instance(); $fallback = $theme->fallback('custom');

get_template

O método get_template retornará a instância de Visualização do modelo de tema carregado atualmente.

$theme = \Theme::instance(); 
$theme->get_template()->set('body', 'Theme can change the look and feel of your app');

set_template

O método set_template permite definir o modelo de tema para a página.

$theme = \Theme::instance(); 
$theme->set_template('layouts/index')->set('body', 'set theme template');

encontrar

find retorna true, se o caminho para o tema for encontrado, caso contrário, retorna false.

$theme = \Theme::instance(); 
$path = $theme->find('newtheme')

todos

all método retorna uma matriz de todos os temas em todos os caminhos de tema.

$theme = \Theme::instance(); $themes = $theme->all();

obter informação

O método get_info retorna uma variável específica do array de informações do tema. Se nenhum tema for especificado, a matriz de informações do tema ativo será usada.

$theme = \Theme::instance(); 
$var = $theme->get_info('color', 'green', 'newtheme');

Aqui, o método get the color é definido em 'newtheme'. Se não for definido, usará 'verde' como cor padrão.

set_info

O método set_info define uma variável no tema ativo ou de fallback.

$theme->set_info('color', 'green', 'fallback');

set_partial

O método set_partial permite definir uma visualização parcial para uma seção nomeada de seu modelo de página. Normalmente, isso é feito via ligação HMVC.

$theme = \Theme::instance(); 
$theme->set_template('layouts/homepage'); $theme->set_partial('navbar', 'homepage/navbar');

get_partial

O método get_partial permite obter a instância de visualização de um parcial previamente definido em uma seção nomeada de seu modelo de página.

$theme = \Theme::instance(); $theme->set_partial('sidebar', 'partials/menu'); 
$theme->get_partial('sidebar', 'partials/menu')->set('class', 'menu green');

Exemplo de Trabalho

Vamos adicionar suporte a temas em nosso aplicativo de funcionários.

Step 1 - Adicione um novo arquivo de configuração de tema, fuel / app / config / theme.php com o seguinte conteúdo.

<?php  
   return array ( 
      'active' => 'tpthemes',
      'fallback' => 'tpthemes', 
      'paths' => array (APPPATH.'themes', ), 
      'assets_folder' => 'assets', 
      'view_ext' => '.html', 
      'require_info_file' => false, 
      'info_file_name' => 'themeinfo.php', 
      'use_modules' => false, 
   );

Step 2 - Adicionar nova pasta de ativos, public / assets / tpthemes / css para o tema, tpthemes.

cd /go/to/app/root/path 
mkdir -p public/assets/tpthemes/css

Step 3 - Baixe o bootstrap mais recente e coloque o bootstrap.min.css em public / assets / tpthemes / css

Step 4 - Adicione uma nova pasta, tpthemes sob a pasta fuel / app / themes.

cd /go/to/app/root/path   
mkdir -p fuel/app/themes/tpthemes

Step 5 - Adicione um novo modelo de layout, bootstrap.html em fuel / app / themes / tpthemes / layout / e adicione o seguinte código.

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <title>Theme example</title> 
      <meta charset = "utf-8"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1"> 
      <!-- Bootstrap core CSS --> 
      <?php echo \Theme::instance()->asset->css('bootstrap.min.css'); ?> 
   </head> 
   
   <body> 
      <?php echo $header; ?> 
      <div class = "container"> 
         <div class = "row">
            <div class = "col-sm-12"> 
               <?php echo $content; ?> 
            </div> 
         </div> 
      </div> 
   </body>
   
</html>

Aqui, usamos a instância do tema e o método do ativo para obter o caminho do arquivo de bootstrap. Definimos duas variáveis, cabeçalho e conteúdo.header é definido para definir os detalhes do cabeçalho dinamicamente. content é definido para definir o conteúdo real da página dinamicamente.

Step 6 - Adicione um novo template de cabeçalho, header.php em fuel / app / themes / tpthemes / partials como segue.

<div class = "jumbotron text-center">
   <h1>Theme support in fuelphp</h1> 
   <p>bootstrap based template</p>  
</div>

Step 7 - Crie um novo controlador, ThemeSample em fuel / app / classes / controller / themesample.php e action em action_index da seguinte maneira.

<?php  
   class Controller_ThemeSample extends \Controller { 
      public function before() { 
         $this->theme = \Theme::instance(); 
         $this->theme->set_template('layouts/bootstrap'); $header = $this->theme->view('partials/header'); $this->theme->get_template()->set('header', $header); } public function action_index() { $content = $this->theme ->view('themesample/index') ->set('message', 'This data comes from action page'); $this->theme 
         ->get_template() 
         ->set('content', $content); } public function after($response) { 
         if (empty($response) or ! $response instanceof Response) { 
            $response = \Response::forge(\Theme::instance()->render()); } return parent::after($response); 
      } 
   }

Aqui, nós usamos before e after método para fazer a inicialização do tema usando métodos de Themeclasse. Alguns dos métodos usados ​​são instance, get_template, set_template e view.

Step 8 - Finalmente, adicione visão para a ação do índice, index.php em fuel / app / themes / tpthemes / themesample como segue.

<p>The data comes from *fuel/app/themes/tpthemes/themesample/index.html* file.</p> 
<p> 
   <?php echo $message; ?> 
</p>

Aqui, definimos uma variável, mensagem, que precisa ser configurada dinamicamente no controlador.

Criamos um novo tema, tpthemes e usei em ThemeSamplecontrolador. Vamos agora verificar o resultado solicitando a URL, http: // localhost: 8080 / themesample / index. O resultado é o seguinte.

O módulo é uma ótima maneira de escrever funcionalidades reutilizáveis ​​da web, como blog, álbum, chat, etc. O módulo não perturba o outro código no aplicativo da web. Ele fica em sua própria pasta e silenciosamente fornece sua funcionalidade. Módulos são simplesmente o mesmo controlador, modelos e visualizações, exceto que eles são agrupados, configurados e colocados em uma pasta especial. Normalmente, um módulo normalmente reside no subdiretório do aplicativo chamado modules, localizado em fuel / app / modules.

Configuração do Módulo

Podemos definir o caminho dos módulos no arquivo de configuração do aplicativo principal, fuel / app / config / config.php, como segue.

'module_paths' => array ( 
   path/to.’modules'.DS,              // path to application modules 
   path/to.’..’.DS.'globalmods'.DS    // path to our global modules 
),

Espaço de nome do módulo

No FuelPHP, cada módulo tem seu próprio namespace PHP. Definir um namespace separado corrige os conflitos de nome. Por exemplo, um módulo de funcionário pode ser definido no namespace, EmployeeModule da seguinte maneira.

<?php  
   namespace Employeemodule;  

   class Controller_Employee { 
      //code here 
   }

O módulo deve ter um nome idêntico ao nome da pasta do módulo.

Estrutura do Módulo

Podemos criar um módulo criando um nome de pasta definido na configuração. O nome da pasta determina o nome do módulo e o nome do namespace para as classes no módulo.

A estrutura do módulo é a seguinte -

• classes
  • controller
  • model
  • view
• config
• lang
• tasks
• views

O módulo pode ter seus próprios arquivos de configuração. É muito útil na configuração do roteamento e não atrapalha a configuração original da aplicação. Outro conceito importante é que a classe do módulo pode ser reutilizada carregando o módulo na seção de configuração always_load como segue.

'always_load => array ( 
   'modules' => array('employeemodule'), 
),

Além disso, os módulos podem ser carregados e usados ​​instantaneamente sem a configuração a seguir.

Module::load('employeemodule');  
\Employeemodule\Myclass::mymethod('params');

Os pacotes são semelhantes aos módulos na reutilização de código, mas diferem nas seguintes maneiras,

• Não mapeia para os URLs da web
• Não é acessível por meio de solicitações HMVC

Resumindo, os pacotes não são funcionalidades diretas da web, como blog, álbum, etc. Em vez disso, são uma biblioteca de funções agrupadas, como processamento de e-mail, criação de documentos, criação de gráficos, autenticação, etc., que auxiliam no desenvolvimento mais rápido da web inscrição.

Criando Pacotes

Para criar um pacote, primeiro precisamos organizar nosso código-fonte especificado a seguir.

/fuel 
   /packages 
      /package (root directory of package) 
         /bootstrap.php 
      /classes 
         /our.php 
      /classes.php 
         /here.php 
      /config 
         /config.php 
         /and_so_on

A estrutura do pacote possui dois arquivos específicos do pacote, arquivos config.php e bootstrap.php. O objetivo do arquivo de configuração é agrupar a configuração do pacote na própria pasta do pacote sem perturbar o aplicativo principal. O objetivo do arquivo de bootstrap é definir o namespace para que o autoloader o carregue corretamente.

Algumas maneiras de definir o namespace são as seguintes,

Autoloader::add_namespace('Mypackage', __DIR__.'/classes/'); 
Autoloader::add_core_namespace('Mypackage'); 
Autoloader::add_core_namespace('Mypackage', true); 
Autoloader::add_classes (array( 
   'Mypackage\\Classname' => __DIR__.'/classes/classname.php', 
   'Mypackage\\Anotherclass' => __DIR__.'/classes/anotherclass.php', 
));

Depois que o arquivo de bootstrap estiver configurado corretamente e os pacotes carregados no aplicativo, podemos usá-lo da seguinte maneira.

$instance = new Myclass; 
$instance = new Mynamespace\Myclass;

Instalando Pacotes

Os pacotes são geralmente colocados no diretório fuel / packages. Por padrão, os seguintes pacotes são instalados,

• auth - Pacote de autenticação

• email - Pacote de e-mail

• oil - Comando de combustível, pacote de óleo

• orm - Pacote ORM

• parser - Pacote do analisador Markdown

Para instalar um novo pacote, a seguir estão as duas opções,

Option 1 - Instalação manual - baixe e instale

Para instalar manualmente o pacote, primeiro baixe o pacote do site do autor. Descompacte-o e coloque-o sobfuel/packages/ pasta.

Option 2 - Método automático usando o comando de óleo

FuelPHP fornece uma maneira automatizada de instalar os pacotes hospedados no github. Use o seguinte comando para instalar o pacote, mytestpackage.

php oil package install mytestpackage

Ele clona o código-fonte do pacote usando o cliente git e o move para a pasta fuel / packages. Se o cliente git não estiver disponível, podemos usar o argumento do comando –direct para direcionar o comando para baixar e instalar os pacotes como segue.

php oil package install mytestpackage --direct

Usando Pacotes

Os pacotes podem ser usados ​​no aplicativo depois de carregados no aplicativo. Existem duas maneiras de carregar os pacotes no aplicativo.

Option 1 - Através da classe Package

FuelPHP fornece uma classe, Package para carregar, descarregar e verificar a disponibilidade dos pacotes por meio dos métodos carregar, descarregar e carregar, respectivamente. loadmétodo tem dois parâmetros. O primeiro parâmetro,$package é o nome do pacote e segundo parâmetro, pathé o caminho do pacote. O segundo parâmetro é opcional, se o pacote estiver instalado emfuel/packages pasta.

// load the orm package 
Package::load('orm');  

// load the parser package from a specific directory 
Package::load('parser', '/path/to/packages/dir/');  

// load the non-existent package 
Package::load('awesome'); // Throws a PackageNotFoundException

Option 2 - Por meio do arquivo de configuração

Para carregar um pacote permanentemente, basta adicionar o pacote em always_load entrada de configuração no arquivo de configuração principal, fuel/app/config/config.php. Para carregar o pacote de e-mail, use a seguinte sintaxe.

'always_load' => array ( 
   'packages' => array ( 
      'email', 
   ), 
),

Depois que os pacotes são carregados no aplicativo, podemos usá-lo da seguinte maneira.

$instance = new Myclass; $instance = new Mynamespace\Myclass;

Cookiefornece armazenamento de dados do lado do cliente e suporta apenas uma pequena quantidade de dados. Normalmente, é de 2 KB por domínio e depende do navegador.Sessionfornece armazenamento de dados do lado do servidor e suporta uma grande quantidade de dados. Vamos ver como criar um cookie e uma sessão no aplicativo da web FuelPHP.

Biscoitos

FuelPHP fornece um Cookieclasse para criar um item de cookie. A classe Cookie é usada para criar, atribuir e excluir cookies.

Configurar Cookie

A classe Cookie pode ser configurada globalmente por meio do arquivo de configuração do aplicativo principal, localizado em fuel / app / config / config.php. É definido como segue.

'cookie' => array (  
   
   //Number of seconds before the cookie expires 
   'expiration'  => 0,  
   
   //Restrict the path that the cookie is available to 
   'path'        => '/',  
   
   //Restrict the domain that the cookie is available to 
   'domain'      => null,  
   
   // Only transmit cookies over secure connections 
   'secure'      => false,  
   
   // Only transmit cookies over HTTP, disabling Javascript access 
   'http_only'   => false, 
),

Métodos

A classe Cookie fornece métodos para criar, acessar e excluir um item de cookie. Eles são os seguintes -

conjunto()

O método set é usado para criar uma variável Cookie. Ele contém os seguintes argumentos,

• $name - A chave na matriz $ _COOKIE.

• $value - O valor do cookie.

• $expiration - Número de segundos que o cookie deve durar.

• $path - O caminho no servidor em que o cookie estará disponível.

• $domain - O domínio para o qual o cookie está disponível.

• $secure - Defina como verdadeiro se desejar apenas transmitir cookies por conexões seguras.

• $httponly - Permitir apenas a transmissão de cookies por HTTP, desabilitando o acesso JavaScript.

Cookie::set('theme', 'green');

pegue()

O método get é usado para ler uma variável Cookie. Ele contém os seguintes argumentos,

• $name - A chave na matriz $ _COOKIE.

• $value - O valor a retornar se a chave não estiver disponível no array $ _COOKIE.

Cookie::get('theme');

excluir()

O método delete é usado para excluir uma variável Cookie. Ele contém os seguintes argumentos,

• $name - A chave na matriz $ _COOKIE.

• $value - O valor do cookie.

• $domain - O domínio para o qual o cookie está disponível.

• $secure - Defina como verdadeiro se desejar apenas transmitir cookies por conexões seguras.

• $httponly - Permitir apenas a transmissão de cookies por HTTP, desabilitando o acesso ao JavaScript.

Cookie::delete('theme');

Sessão

FuelPHP fornece classe, Session para manter o estado do aplicativo.

Configurar Sessão

A classe da sessão pode ser configurada através do arquivo de configuração especial, fuel/core/config/session.php. Algumas das entradas de configuração importantes são as seguintes -

• auto_initialize - Inicialize a sessão automaticamente.

• driver- Nome do driver da sessão. A sessão é implementada usando o driver e as opções possíveis são cookie, db, memcached, redis e file. O driver padrão é o cookie.

• match_ip - Verifique o IP do cliente.

• match_ua - Verifique o agente do usuário do cliente.

• expiration_time - Valor do tempo limite da sessão em segundos.

• rotation_time - É hora de renovar a sessão.

Métodos de Sessão

A classe de sessão fornece métodos para manipular os dados da sessão. Eles são os seguintes,

instância()

o instance método retorna um padrão ou uma instância específica, que é identificada pelo nome.

$session = Session::instance(); // default instance $session = Session::instance('myseesion'); // specific instance

conjunto()

o set método é usado para atribuir uma variável de sessão.

Session::set('userid', $userid);

pegue()

o get método permite que você recupere as variáveis ​​armazenadas da sessão.

$userid = Session::get('userid');

excluir()

o delete método permite excluir uma variável de sessão armazenada.

Session::delete('userid');

crio()

o createmétodo permite que você crie uma nova sessão. Se uma sessão já estiver presente, ela será destruída e uma nova sessão será criada.

Session::create();

destruir()

o destroy método é usado para destruir uma sessão existente.

Session::destroy();

ler()

o read método permite que você leia uma sessão.

Session::read();

Escreva()

o write método permite que você escreva a sessão.

Session::write();

chave()

o keymétodo permite recuperar elementos da chave de sessão. O valor da chave é único.

$session_id = Session::key('session_id');

A eventé uma ação ou ocorrência reconhecida pelo programa que pode ser tratada pelo próprio programa. Por exemplo, podemos definir uma ação ou evento denominado my_fuel_event e então fazer algum trabalho sempre que o evento, my_fuel_event for chamado. FuelPHP fornece classe,Event para trabalhar com os eventos no aplicativo.

Eventos do Sistema

O FuelPHP definiu alguns dos eventos por meio dos quais podemos fazer algum trabalho sempre que os eventos definidos forem chamados ou disparados pelo aplicativo. Esta ajuda está mudando o comportamento do FuelPHP sem mudar os arquivos de código do núcleo do FuelPHP. Os eventos pré-definidos são os seguintes -

• app_created - Este evento será acionado depois que o framework FuelPHP for inicializado.

• request_created - Este evento será acionado após um novo objeto Request for forjado.

• request_started - Este evento será acionado quando a execução de uma solicitação for solicitada.

• controller_started - Este evento será disparado antes que o método before () dos controladores seja chamado.

• controller_finished - Este evento será disparado após os controladores após o método () ser chamado e a resposta ser recebida.

• response_created - Este evento será acionado após a falsificação de um novo objeto Response.

• request_finished - Este evento será acionado quando a execução de uma Solicitação for concluída e uma resposta for recebida.

• shutdown - Este evento será acionado após o processamento da solicitação principal e o envio da saída.

Podemos lidar com os eventos no arquivo de configuração especial, fuel/app/config/events.php como segue -

<?php  
   return array ( 
      'fuelphp' => array ( 
         'app_created' => function() { 
            // After FuelPHP initialised
         }, 
         'request_created' => function() { 
            // After Request forged 
         }, 
         'request_started' => function() { 
            // Request is requested 
         }, 
         'controller_started' => function() { 
            // Before controllers before() method called 
         }, 
         'controller_finished' => function() { 
            // After controllers after() method called 
         }, 
         'response_created' => function() { 
            // After Response forged 
         }, 
         'request_finished' => function() { 
            // Request is complete and Response received 
         }, 
         'shutdown' => function() { 
            // Output has been send out 
         }, 
      ), 
   );

Métodos de Evento

A classe Event fornece métodos para registrar, cancelar o registro e disparar eventos. Eles são os seguintes,

registro()

O método de registro permite que os arquivos registrem um objeto que será executado quando o método de disparo for chamado.

$my_event_code = function() { 
   echo 'my event'; 
} 
Event::register('my_event', $my_event_code);

cancelar o registro ()

O método de cancelamento de registro permite que os arquivos cancelem o registro de um objeto que seria executado quando o método de disparo fosse chamado.

Event::unregister('my_event', $my_event_code);

desencadear()

O método de disparo é usado para disparar ou ativar retornos de chamada associados através do método de registro.

Event::trigger('my_event');

has_events ()

O método has_events está disponível para que você possa verificar se um determinado evento registrado tem gatilhos.

Event::has_events('my_event');

forja()

A forja retorna um novo objeto de evento.

$event = Event::forge();

instância()

A instância retorna um novo singleton de objeto de evento.

$event = Event::instance('event_instance');

A funcionalidade de e-mail é o recurso mais solicitado em uma estrutura da web. FuelPHP fornece uma classe de e-mail elegante agrupada como um pacote. Ele é usado para enviar e-mail de texto simples simples, bem como e-mail rich text avançado com vários anexos. Ele suporta os seguintes recursos - e-mails de texto simples, e-mails em HTML, anexos e anexos inline.

Configuração

Para habilitar a funcionalidade de e-mail no aplicativo, precisamos apenas carregar o pacote de e-mail conforme especificado abaixo no arquivo de configuração principal, fuel / app / config / config.php.

'always_load' => array ( 
   'packages' => array ( 
      'email', 
   ), 
),

Outra opção é carregar o pacote de email, o próprio controlador da seguinte maneira.

\Package::load('email');

A configuração do e-mail pode ser feita no arquivo de configuração principal e algumas das opções importantes são as seguintes,

• driver - Driver de e-mail como smtp

• is_html - Se enviar e-mail como conteúdo HTML ou não

• priority - Prioridade do email

• smtp.host - host do servidor SMTP

• smtp.port - Porta do servidor SMTP

• smtp.username - Nome de usuário do servidor SMTP

• smtp.password - senha do servidor SMTP

• smtp.timeout - tempo limite de SMTP

• smtp.starttls - Se o servidor SMTP precisa do comando STARTTLS

API de email

A seguir estão a API fornecida pela classe de driver de email e email.

forja

Objetivo: Criar uma instância de driver de e-mail. Ele cria o driver com base na configuração ou na entrada que recebe. O driver de email fornece recursos para criar e enviar email. Alguns dos possíveis drivers de e-mail sãosmtp, sendmail, mailgun, e mandrill.

• Parameter - Nenhum ou conjunto de detalhes de configuração

• Returns - Retorna o objeto Email_Driver

Por exemplo,

$email = \Email::forge(); $email = \Email::forge (array( 
   'driver' => 'smtp', 
));

corpo

• Purpose - Para definir o corpo da mensagem

• Parameter - $ body - corpo da mensagem

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); 
$email->body('Body message'); //or pass it a View $email->body(\View::forge('my/view', $data);

alt_body

• Purpose - Para definir o corpo da mensagem alternativa

• Parameter - $ alt_body - corpo alternativo da mensagem

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); $email->alt_body('Body message');  

//or pass it a View 
$email->alt_body(\View::forge('my/view', $data);

prioridade

• Purpose - Para definir a prioridade do correio

• Parameter -

  • $priority- valor da prioridade. As opções são -

a. \Email::P_LOWEST 
* \Email::P_LOW 
* \Email::P_NORMAL 
* \Email::P_HIGH 
* \Email::P_HIGHEST

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); 
$email->priority(\Email::P_HIGHEST);

html_body

• Purpose - Para definir o corpo da mensagem no formato HTML

• Parameter -

  • $html - corpo da mensagem em HTML;

  • generate_alt - se deve gerar mensagem alternativa;

  • auto_attach - se deseja incorporar a imagem ou não

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); // Do generate the alt body, but don't auto attach images. $email->html_body(\View::forge('welcome/email', $data), true, false);

de

• Purpose - Para definir o endereço de

• Parameters -

  • $from - do endereço de e-mail;

  • $name - Nome do remetente

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); 
$email->from('[email protected]', 'My Name');

sujeito

• Purpose - Para definir o assunto da mensagem

• Parameter - $ subject - assunto da mensagem de e-mail

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); $email->subject('Suject of the mail message');

para

• Purpose - Para definir o endereço de e-mail do destinatário

• Parameters -

  • $email - endereço de e-mail ou matriz de endereço de e-mail;

  • $name - nome do receptor

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); $email->to('[email protected]', 'My Dear Name'); 
$email->to (array( 
   '[email protected]', 
   '[email protected]' => 'My Dear friend', 
));

cabeçalho

• Purpose - Para definir o cabeçalho personalizado da mensagem de e-mail

• Parameters -

  • $header - tipo de cabeçalho ou matriz de cabeçalho;

  • $value - valor do cabeçalho

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge(); 
$email->header('X-SMTPAP', 'XXXXXXXX'); $email>reply_to (array( 
   'X-SMTPAP'  => 'XXXXXX', 
   'X-SMTPAP2' > 'XXXXXA',
));

anexar

• Purpose - Para anexar um arquivo à mensagem de e-mail

• Parameters-

  • $file - caminho do arquivo;

  • $inline - se deseja anexar o arquivo inline ou não;

  • $cid - identificador de conteúdo;

  • $mime - Tipo MIME do arquivo anexo;

  • $name - substituição do nome do arquivo de anexo

• Returns - Retorna a instância atual

Por exemplo,

$email = \Email::forge();
$email>attach(DOCROOT.'attachments/sample_attachment.pdf');

enviar

• Purpose - Para enviar o e-mail.

• Parameter -

  • $validate - validar os endereços de e-mail

• Returns - verdadeiro ou falso

Por exemplo,

$email = \Email::forge(); try{ $email->send(); 

} catch(\EmailSendingFailedException $e) { // The driver could not send the mail. } catch(\EmailValidationFailedException $e) { 
   // One or more email addresses failed validation. 
}

Amostra de Email Prático

Vamos usar a API aprendida no capítulo anterior e criar um código simples para enviar uma mensagem. A seguir está o código mais simples para enviar uma mensagem.

$email = Email::forge(); $email->from('[email protected]', 'person1'); 
$email->to('[email protected]', 'person2'); $email->subject('Add something'); 
$email->body('contents of mail'); $email->send();

Profileré uma das ferramentas importantes para analisar e melhorar o desempenho do aplicativo. O FuelPHP fornece um excelente perfilador para o perfil do aplicativo. Vamos aprender sobre o perfil no FuelPHP neste capítulo.

Habilitar criação de perfil

A criação de perfil está desabilitada por padrão. Para habilitar a criação de perfil, defina o perfil de atributo como verdadeiro no arquivo de configuração principal, fuel / app / config / config.php como segue.

'profiling'  => true,

Agora, a criação de perfil está habilitada no aplicativo. Uma vez habilitada a criação de perfil, todas as páginas solicitadas mostrarão uma guia extra na parte inferior da página com informações de criação de perfil, conforme mostrado na captura de tela a seguir.

Informação do Profiler

O Profiler tem uma interface com guias e consiste nos seguintes dados,

• Console - Fornece informações sobre erros, entradas de log, uso de memória ou tempos de execução.

• Load time - Mostra o tempo de carregamento do pedido.

• Database - O número de consultas executadas e o tempo de execução.

• Memory - Memória total usada para a solicitação.

• Files - Mostra todos os arquivos PHP.

• Config - Conteúdo da configuração no final do pedido.

• Session - Conteúdo da sessão no final da solicitação.

• GET - O conteúdo da matriz $ _GET.

• POST - O conteúdo da matriz $ _POST.

Classe Profiler

A classe profiler é usada para adicionar suas informações de criação de perfil. Ele implementa uma versão personalizada do PHPQuickProfiler (PQP). O Profiler contém uma coleção de variáveis ​​javaScript para controlar o estado inicial do Profiler.

Profiler classe suporta o seguinte methods -

marca()

O método mark adicionará um marcador de velocidade ao criador de perfil. Mostra o tempo de carregamento.

Profiler::mark('my custom code');

mark_memory ()

O método * mark_memory * adiciona um marcador de memória ao criador de perfil. Se nenhuma entrada for especificada, o uso da memória naquele momento será registrado. Se especificarmos a variável e um rótulo para a variável conforme mostrado abaixo, ele mostrará o uso de memória da variável e a rotulará usando o rótulo especificado.

mark_memory($this, 'My Employee Controller memory usage');

console()

O método do console simplesmente adicionará uma entrada de registro ao criador de perfil.

Profiler::console('log entry');

FuelPHP fornece um excelente suporte para lidar com erros e depurar o aplicativo. Vamos entender o tratamento de erros e a depuração neste capítulo.

Manipulação de erros

O tratamento de erros do FuelPHP é baseado em exceções. FuelPHP fornece exceção PhpErrorException para todos os erros de php antigos. FuelPHP dispara PhpErrorException sempre que um erro no código PHP é encontrado. O FuelPHP também facilita a exibição de páginas de erro personalizadas para vários códigos de status HTTP.

Erro de arquivo não encontrado

FuelPHP fornece uma nova classe de exceção, HttpNotFoundException, para lidar com as solicitações desconhecidas. Às vezes, podemos encontrar a solicitação que pode não ser atendida. Nesse momento, podemos apenas lançar a HttpNotFoundException.

Por padrão, uma página padrão é configurada para HttpNotFoundException no arquivo de configuração de rotas, fuel / app / config / routes.php usando 400 entradas. Sempre que HttpNotFoundException é gerado, a solicitação será redirecionada para a página 400.

'_404_'   => 'welcome/404',    // The main 404 route

Erros Internos

FuelPHP fornece uma nova classe de exceção, HttpServerErrorException, para lidar com todos os erros do servidor. Às vezes, podemos não conseguir processar a solicitação fornecida devido a erros internos. Nesse momento, podemos apenas lançar a HttpServerErrorException.

Por padrão, uma página padrão é configurada para HttpServerErrorException no arquivo de configuração de rotas, fuel / app / config / routes.php usando 500 entradas. Sempre que HttpServerErrorException é gerado, a solicitação será redirecionada para a página 500.

'_500_'   => 'welcome/500',    // The main 500 route

Esta página registrará o erro, mostrará o erro formatado na página e, ocasionalmente, enviará uma notificação ao administrador do sistema.

Erros de violação de acesso

FuelPHP fornece uma nova classe de exceção, HttpNoAccessException, para lidar com as violações de acesso. Às vezes, podemos não conseguir processar a solicitação devido à restrição de acesso. Nesse momento, podemos apenas lançar a HttpNoAccessException.

Por padrão, uma página padrão é configurada para HttpNoAccessException no arquivo de configuração de rotas, fuel / app / config / routes.php usando 403 de entrada. Sempre que HttpNoAccessException é gerado, a solicitação será redirecionada para a página 403.

'_403_'   => 'welcome/403',     // The main 403 route

Esta página mostrará as informações de violação de acesso.

Depurando

A depuração é uma das atividades mais frequentes no desenvolvimento de um aplicativo. FuelPHP fornece uma classe simples,Debugpara lidar com a atividade de depuração do aplicativo. Vamos aprender a classe Debug e seus métodos neste capítulo.

Classe de depuração

A classe Debug fornece métodos utilitários para mostrar informações detalhadas de variáveis, objetos, array, etc. A classe Debug fornece os seguintes métodos,

despejar

O método de despejo retorna vários valores mistos para o navegador de uma forma estruturada e formatada.

Debug::dump($var1, $var2);

backtrace ()

backtrace mostra as informações detalhadas sobre a execução atual do código. Ele mostra as informações do arquivo PHP, a linha atual e todas as suas ações anteriores.

Debug::backtrace();

Aulas()

Retorna uma lista de todas as classes.

Debug::classes();

interfaces ()

Retorna uma lista de todas as classes de interface.

Debug::interfaces();

inclui ()

Retorna uma lista de todos os arquivos incluídos atualmente carregados no tempo de execução.

Debug::includes();

funções()

Retorna uma lista de todas as funções.

Debug::functions();

constantes ()

Retorna uma lista de todas as constantes.

Debug::constants();

extensões ()

Retorna uma lista de todas as extensões.

Debug::extensions();

cabeçalhos ()

Retorna uma lista de todos os cabeçalhos HTTP.

Debug::headers();

phpini ()

Imprime uma lista das definições de configuração lidas do arquivo php.ini.

Debug::phpini();

O teste de unidade é um processo essencial no desenvolvimento de grandes projetos. Unit testsajudam a automatizar o teste dos componentes do aplicativo em todos os estágios de desenvolvimento. Ele alerta quando o componente do aplicativo não está funcionando de acordo com a especificação de negócios do projeto. O teste de unidade pode ser feito manualmente, mas geralmente é automatizado.

PHPUnit

A estrutura FuelPHP se integra à estrutura de teste PHPUnit. Para escrever um teste de unidade para a estrutura FuelPHP, precisamos configurar o PHPUnit. Se o PHPUnit não estiver instalado, faça o download e instale-o. Podemos confirmar a disponibilidade do PHPUnit em nosso sistema usando o seguinte comando.

phpunit --version

Se o PHPUnit estiver disponível, você verá o resultado semelhante ao seguinte.

PHPUnit 5.1.3 by Sebastian Bergmann and contributors.

Criação de testes de unidade

O local padrão fornecido pelo FuelPHP para gravar o teste de unidade é fuel / app / tests. Podemos escrever o teste de unidade para controlador, modelo, exibição e apresentadores em pastas separadas. Vamos escrever um teste de unidade para validar o objeto Model_Employee.

• Step 1 - Crie uma pasta, modelo sob a pasta de combustível / app / testes.

• Step 2 - Crie um arquivo, employee.php em fuel / app / tests / model / folder.

• Step 3 - Crie uma nova classe de teste, Test_Model_Employee estendendo a classe TestCase fornecida pelo PHPUnit.

• Step 4 - Escreva um método, testInstanceOfEmployee () para ativar a criação do objeto funcionário usando o método assertInstanceOf () fornecido pela classe TestCase do PHPUnit.

A seguir está o código completo -

<?php  
   class Test_Model_Employee extends TestCase { 
      public function testInstanceOfEmployee() { 
         $this->assertInstanceOf(Model_Employee::class, new Model_Employee()); 
      } 
   }

Criando um Grupo de Teste

FuelPHP fornece uma opção para criar um grupo de casos de teste. Criar um grupo é tão simples quanto adicionar o atributo docblock, @group. Vamos incluir nosso caso de teste dentro do grupo MyTest.

<?php   
   /** 
      * @group MyTest 
   */ 
   class Test_Model_Employee extends TestCase { 
      public function testInstanceOfEmployee() { 
         $this->assertInstanceOf(Model_Employee::class, new Model_Employee()); 
      } 
   }

Teste de corrida

Para executar todos os testes no diretório, use o seguinte comando.

$ php oil test

Para executar um grupo específico de testes, use o seguinte comando.

$ php oil test --group = MyTest

Depois de executar o comando, você receberá a seguinte resposta.

Tests Running...This may take a few moments.
PHPUnit 5.1.3 by Sebastian Bergmann and contributors.
                                        1 / 1 (100%).
Time: 123 ms, Memory: 8.00Mb
OK (1 test, 1 assertion)

Neste capítulo, aprenderemos como criar um aplicativo BookStore baseado em MVC completo no FuelPHP.

etapa 1: criar um projeto

Crie um novo projeto chamado “BookStore” no FuelPHP usando o seguinte comando.

oil create bookstore

etapa 2: crie um layout

Crie um novo layout para nosso aplicativo. Crie um arquivo, layout.php no local fuel / app / views / layout.php. O código é o seguinte,

fuel / app / views / layout.php

<!DOCTYPE html> 
<html lang = "en"> 
   <head> 
      <meta charset = "utf-8"> 
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1">  
      <title><?php echo $title; ?></title>  
      
      <!-- Bootstrap core CSS --> 
      <link href = "/assets/css/bootstrap.min.css" rel = "stylesheet">  
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
      </script> 
      <script src = "/assets/js/bootstrap.min.js"></script> 
   </head>  
   
   <body> 
      <nav class = "navbar navbar-inverse navbar-fixed-top"> 
         <div class = "container"> 
            <div class = "navbar-header">
               
               <button type = "button" class = "navbar-toggle collapsed" 
                  datatoggle = "collapse" data-target = "#navbar" 
                  aria-expanded = "false" ariacontrols = "navbar"> 
                  <span class=  "sr-only">Toggle navigation</span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
                  <span class = "icon-bar"></span> 
               </button> 
               <a class = "navbar-brand" href = "#">FuelPHP Sample</a> 
            </div> 
            
            <div id = "navbar" class = "collapse navbar-collapse"> 
               <ul class = "nav navbar-nav"> 
                  <li class = "active"><a href = "/book/index">Home</a></li> 
                  <li><a href = "/book/add">Add book</a></li> 
               </ul> 
            </div><!--/.nav-collapse --> 
         </div> 
      </nav>  
      
      <div class = "container"> 
         <div class = "starter-template" style = "padding: 50px 0 0 0;"> 
            <?php echo $content; ?> 
         </div> 
      
      </div><!-- /.container --> 
   </body>
   
</html>

Aqui, estamos usando o modelo de bootstrap. FuelPHP tem suporte de primeira classe para modelos de bootstrap. Criamos duas variáveis, título e conteúdo. o título é usado para especificar o título da página atual e o conteúdo é usado para especificar os detalhes da página atual.

etapa 3: Crie um controlador

Crie um novo controlador, Controller_Book para mostrar, adicionar, editar e deletar o livro. Crie um novo arquivo, fuel / app / classes / controller / book.php e coloque o seguinte código.

fuel / app / classes / controller / book.php

<?php  
   class Controller_Book extends Controller_Template {
      public $template = 'layout'; 
      public function action_index() { 
         
         // Create the view object 
         $view = View::forge('book/index'); // set the template variables $this->template->title = "Book index page"; 
         $this->template->content = $view; 
      } 
   }

Aqui, criamos o controlador de livro herdando o controlador de modelo e definimos o modelo padrão como fuel / app / views / layout.php.

etapa 4: crie a visualização do índice

Crie uma pasta, reserve no diretório views na pasta fuel / app / views. Em seguida, crie um arquivo index.php dentro da pasta do livro e adicione o seguinte código,

fuel / app / views / index.php

<h3>index page</h3>

A partir de agora, criamos um controlador de livro básico.

etapa 5: modificar a rota padrão

Atualize a rota padrão para definir a página inicial do aplicativo como controlador de livro. Abra o arquivo de configuração de roteamento padrão, fuel / app / config / routes.php e altere-o como segue.

fuel / app / config / routes.php

<?php 
   return array ( 
      '_root_'  => 'book/index',  // The default route 
      '_404_'   => 'welcome/404', // The main 404 route 

      'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'), 
   );

Agora, solicitando a URL, http: // localhost: 8080 / retornará a página de índice do controlador de livro da seguinte maneira,

etapa 6: Criar banco de dados

Crie um novo banco de dados no servidor MySQL, usando o seguinte comando,

create database tutorialspoint_bookdb

Em seguida, crie uma tabela dentro do banco de dados usando o seguinte comando,

CREATE TABLE book ( 
   id INT PRIMARY KEY AUTO_INCREMENT, 
   title VARCHAR(80) NOT NULL, 
   author VARCHAR(80) NOT NULL, 
   price DECIMAL(10, 2) NOT NULL 
);

Insira algum registro de amostra na tabela usando a seguinte instrução SQL.

INSERT 
INTO 
   book(title, 
   author, 
   price) 
VALUES( 
   'The C Programming Language', 
   'Dennie Ritchie', 
   25.00 
),( 
   'The C++ Programming Language', 
   'Bjarne Stroustrup', 
   80.00
),( 
   'C Primer Plus (5th Edition)', 
   'Stephen Prata', 
   45.00 
),('Modern PHP', 'Josh Lockhart', 10.00),( 
   'Learning PHP, MySQL & JavaScript, 4th Edition', 
   'Robin Nixon', 
   30.00 
)

etapa 7: configurar o banco de dados

Configure o banco de dados usando o arquivo de configuração do banco de dados, db.php localizado em fuel / app / config.

fuel / app / config / db.php

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_bookdb', 
            'username'       => 'root', 
            'password'       => 'password', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_bookdb', 
            'username'       => 'root', 
            'password'       => 'password', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

etapa 8: Incluir pacote Orm

Atualize o arquivo de configuração principal para incluir o pacote ORM. Ele está localizado em “fuel / app / config /”.

fuel / app / config / config.php

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

etapa 9: Crie um modelo

Crie um modelo de livro em book.php localizado em “fuel / app / classes / model”. É definido da seguinte forma -

combustível / app / classes / model / book.php

<?php  
   class Model_Book extends Orm\Model { 
      protected static $_connection = 'production'; protected static $_table_name = 'book'; 
      protected static $_primary_key = array('id'); protected static $_properties = array ( 
         'id',  
         'title' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Book title', 
            'validation' => array ( 
               'required',  
               'min_length' => array(3),  
               'max_length' => array(80) 
            ), 
            
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
         'author' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Book author', 
            'validation' => array ( 
               'required', 
            ), 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
         'price' => array ( 
            'data_type' => 'decimal', 
            'label' => 'Book price', 
            'validation' => array ( 
               'required', 
            ), 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      );  
      protected static $_observers = array('Orm\\Observer_Validation' => array ( 
         'events' => array('before_save') 
      )); 
   }

Aqui, especificamos os detalhes do banco de dados como propriedades do modelo. Ele também possui detalhes de validação.

passo 10: Exibir livros

Atualize a ação do índice no controlador de livro para listar os livros disponíveis no banco de dados.

fuel / app / classes / controller / book.php

<?php  
   class Controller_Book extends Controller_Template { 
      public $template = 'layout'; 
      public function action_index() { 
         
         // Create the view object 
         $view = View::forge('book/index'); // fetch the book from database and set it to the view $books = Model_Book::find('all'); 
         $view->set('books', $books);  
         
         // set the template variables
         $this->template->title = "Book index page"; $this->template->content = $view; 
      } 
   }

Aqui, usamos o orm para buscar os detalhes do livro no banco de dados e, em seguida, passar os detalhes do livro para visualizações.

passo 11: Atualizar visualização do índice

Atualize o arquivo de visualização index.php localizado em “fuel / app / views / book”. O código atualizado completo é o seguinte,

fuel / app / views / book / index.php

<table class = "table"> 
   <thead> 
      <tr> 
         <th>#</th> 
         <th>Title</th> 
         <th>Author</th> 
         <th>Price</th> 
         <th></th> 
      </tr> 
   </thead> 
   
   <tbody> 
      <?php 
         foreach($books as $book) { ?> <tr> <td><?php echo $book['id']; ?></td> 
         <td><?php echo $book['title']; ?></td> <td><?php echo $book['author']; ?></td> 
         <td><?php echo $book['price']; ?></td> <td> <a href = "/book/edit/<?php echo $book['id']; ?>">Edit</a> 
            <a href = "/book/delete/<?php echo $book['id']; ?>">Delete</a> 
         </td>
      </tr> 
      
      <?php 
      } 
      ?> 
   </tbody> 
</table> 
<ul>
</ul>

Agora, solicitando o URL, http: // localhost: 8080 / mostrará a página da seguinte maneira -

etapa 12: Criar ação para adicionar livro

Crie a funcionalidade para adicionar um novo livro à livraria. Crie uma nova ação, action_add no controlador de livro da seguinte maneira,

public function action_add() { 
   
   // create a new fieldset and add book model 
   $fieldset = Fieldset::forge('book')->add_model('Model_Book');  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form 
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('book/add')); $view = View::forge('book/add'); 
   $view->set('form', $formHtml, false);  
   
   if (Input::param() != array()) { 
      try { 
         $book = Model_Book::forge(); $book->title = Input::param('title'); 
         $book->author = Input::param('author'); $book->price = Input::param('price'); 
         $book->save(); Response::redirect('book'); } catch (Orm\ValidationFailed $e) { 
         $view->set('errors', $e->getMessage(), false); 
      } 
   }  
   $this->template->title = "Book add page"; $this->template->content = $view; }

Aqui, os dois processos a seguir estão sendo realizados,

• Construindo o formulário de livro para adicionar livro usando métodos Fieldset e modelo de livro.

• Processamento do formulário de livro, quando o usuário insere as informações do livro e devolve o formulário. Ele pode ser encontrado verificando o método Input :: param () para quaisquer dados enviados. O processamento do formulário envolve as seguintes etapas -

  • Reúna as informações do livro.

  • Valide as informações do livro. Já definimos a validação a ser chamada antes do método de salvamento. Se a validação falhar, ela lançará a exceção Orm \ ValidationFailed.

  • Armazene as informações do livro no banco de dados.

  • Redirecione o usuário para a página de índice em caso de sucesso. Caso contrário, mostre o formulário novamente.

Estamos fazendo ambos, mostrando o formulário e também processando o formulário na mesma ação. Quando o usuário chama a ação pela primeira vez, ele mostra o formulário. Quando o usuário insere as informações do livro e envia os dados, ele processa o formulário.

etapa 13: crie a visualização para adicionar ação de livro

Crie a visualização para adicionar ação de livro. Crie um novo arquivo, fuel / app / views / book / add.php e digite o seguinte código,

<style>  
   #form table { 
      width: 90%; 
   }  
   #form table tr { 
      width: 90% 
   }  
   #form table tr td { 
      width: 50% 
   }  
   #form input[type = text], select { 
      width: 100%; 
      padding: 12px 20px; 
      margin: 8px 0; 
      display: inline-block; 
      border: 1px solid #ccc; 
      border-radius: 4px; 
      box-sizing: border-box; 
   }  
   #form input[type = submit] { 
      width: 100%;
      background-color: #3c3c3c; 
      color: white; 
      padding: 14px 20px; 
      margin: 8px 0; 
      border: none; 
      border-radius: 4px; 
      cursor: pointer; 
   }  
   #form div { 
      border-radius: 5px; 
      background-color: #f2f2f2; 
      padding: 20px; 
   }  
</style>  

<div id = "form">  
   <h2>Book form</h2> 
   
   <?php   
      if(isset($errors)) { 
         echo $errors; } echo $form;  
   ?> 
</div>

Aqui, estamos apenas mostrando o formulário criado no método de ação. Além disso, estamos mostrando os erros, se houver.

etapa 14: Verificar a ação adicionar livro

Solicitar o url, http: // localhost: 8080 / book / add ou clicar no link de navegação Adicionar livro, mostrará o formulário a seguir,

Formato

Formulário com dados

Depois de inserir as informações do livro e enviar a página, as informações do livro serão armazenadas no banco de dados e a página será redirecionada para a página de índice da seguinte forma.

Lista de livros com livro adicionado recentemente

etapa 15: Criação de ação para editar o livro

Crie a funcionalidade para editar e atualizar as informações do livro existente. Crie uma nova ação, action_edit no controlador de livro como segue.

public function action_edit($id = false) { if(!($book = Model_Book::find($id))) { throw new HttpNotFoundException(); } // create a new fieldset and add book model $fieldset = Fieldset::forge('book')->add_model('Model_Book'); 
   $fieldset->populate($book);  
   
   // get form from fieldset 
   $form = $fieldset->form();  
   
   // add submit button to the form
   $form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit')); // build the form and set the current page as action $formHtml = $fieldset->build(Uri::create('book/edit/' . $id));  
   $view = View::forge('book/add'); $view->set('form', $formHtml, false); if (Input::param() != array()) { try { $book->title = Input::param('title'); 
         $book->author = Input::param('author'); $book->price = Input::param('price'); 
         $book->save(); Response::redirect('book'); } catch (Orm\ValidationFailed $e) { 
         $view->set('errors', $e->getMessage(), false); 
      } 
   }  
   $this->template->title = "Book edit page"; $this->template->content = $view; 
}

É semelhante à ação adicionar, exceto que pesquisa o livro solicitado por id antes de processar a página. Se alguma informação do livro for encontrada no banco de dados, ele prosseguirá e mostrará as informações do livro no formulário. Caso contrário, ele lançará a exceção arquivo não encontrado e sairá.

etapa 16: crie a visualização para a ação de edição

Crie a visualização para editar a ação do livro. Aqui, estamos usando a mesma visualização usada para adicionar ação.

etapa 17: Verificar a ação de edição do livro.

Clique no link editar de qualquer livro na página de lista de livros, ele mostrará o formulário de livro correspondente da seguinte forma -

Formulário com detalhes do livro

etapa 18: Criar ação para excluir o livro

Crie a funcionalidade para excluir o livro da livraria. Crie uma nova ação, action_delete no controlador de livro da seguinte maneira,

public function action_delete($id = null) { 
   if ( ! ($book = Model_Book::find($id))) { 
      throw new HttpNotFoundException(); 

   } else { 
      $book->delete(); 
   } 
   Response::redirect('book'); 
}

Aqui, estamos verificando a existência de um livro no banco de dados usando o id de livro fornecido. Se o livro for encontrado, ele será excluído e redirecionado para a página de índice. Caso contrário, uma página não encontrada informação será mostrada.

passo 19: Verificar a ação de exclusão

Verifique a ação de exclusão clicando no link excluir na página de listagem do livro. Isso excluirá o livro solicitado e, em seguida, será redirecionado novamente para a página de índice.

Por fim, são criadas todas as funcionalidades para adicionar, editar, excluir e listar as informações do livro.

O FuelPHP é simples, flexível, escalonável e facilmente configurável em comparação com outras estruturas PHP baseadas em MVC. Ele fornece todos os recursos da estrutura MVC moderna. Ele pode ser usado como está ou pode ser alterado completamente para atender às nossas necessidades. Acima de tudo, é uma ótima opção para desenvolvimento web.