bernacamargo/template_codeigniter-3.1.10

Template for the CodeIgniter framework

Maintainers

Details

github.com/bernacamargo/codehead

Source

Issues

Forum

Wiki

Installs: 9

Dependents: 0

Suggesters: 0

Security: 0

Stars: 5

Watchers: 2

Forks: 1

Open Issues: 0

Type:project

v1.2 2019-06-05 15:54 UTC

Requires

  • php: >=5.3.7

Requires (Dev)

Suggests

MIT d701593798fff8bb4af78237fcda97da6b2020d0

This package is auto-updated.

Last update: 2024-03-22 02:36:04 UTC

README

CodeHead é uma biblioteca com otimizações voltada para diminuir a repetição de código e aumentar a produtividade através de métodos úteis. Utilizaremos Twitter Bootstrap 4, JQuery 3.4.1, Font-awesome 5.8.1, Toastr, Core System Classes e Bibliotecas para manipular funções do Codeigniter 3.

  • Links úteis

Sumário

Instalando

Faça o download como ZIP ou clone o repósitorio em seu ambiente local, em seguida basta realizar a configuração da aplicação e começar a usa-la para desenvolver sua sistema web.

Configurando

Conectando ao Banco de Dados

Credenciais do banco configuradas em application/config/database.php

  • Troque os valores YOURHOST, DB_USERNAME, DB_PASSWORD e DB_NAME pelo host, username, senha e nome do banco de dados respectivamente
$db['default'] = array(
    'dsn'   => '',
    'hostname' => 'YOURHOST',
    'username' => 'DB_USERNAME',
    'password' => 'DB_PASSWORD',
    'database' => 'DB_NAME',
    'dbdriver' => 'mysqli',
    'dbprefix' => '',
    'pconnect' => FALSE,
    'db_debug' => (ENVIRONMENT !== 'production'),
    'cache_on' => FALSE,
    'cachedir' => '',
    'char_set' => 'utf8',
    'dbcollat' => 'utf8_general_ci',
    'swap_pre' => '',
    'encrypt' => FALSE,
    'compress' => FALSE,
    'stricton' => FALSE,
    'failover' => array(),
    'save_queries' => TRUE
);

Helper functions

O template possui algumas funções pré-definidas em PHP para facilitar no seu desenvolvimento.

  • debug()
  • str_slug()
  • format_money()
  • validate_card()
  • time_ago()
  • hextorgba()

Funções

  • debug()
/**
 * debug
 *
 * Exibe o conteúdo detalhado e identado de uma variável no PHP
 * 
 * @param  Array $arry
 * @return void
 */
function debug($arry) {
	echo '<pre>' . var_export($arry, TRUE) . '</pre>';
}
  • str_slug()
/**
 * str_slug
 *
 * Normaliza uma string removendo todos os caracteres especiais, espaços e acentos.
 * 
 * @param  String $str
 * @return String
 */
function str_slug($str) {
    return url_title(convert_accented_characters($str), "-", true);
}
  • format_money()
/**
 * format_money
 *
 * Recebe um valor float/ e converte para a exibição padrão do Real com 2 casas decimais, separando os decimais com virgula e a casa de milhares com ponto.
 * 
 * @param  Mixed $money
 * @return void
 */
function format_money($money) {
    $money = floatval($money);
    echo number_format($money, 2, ',', '.');
}
  • validate_card()
/**
 * validate_card
 *
 * Recebe um número de cartão de crédito e retorna o número do cartão, a bandeira dele e se é valido ou não.
 * 
 * @param  String $number
 * @return array $return
 */
function validate_card($number){
    // Remove spaces
    $number = str_replace(" ", "", $number);

    $cardtype = array(
        'visa'              =>    "/^4\d{3}-?\d{4}-?\d{4}-?\d{4}$/",
        'mastercard'        =>    "/^5[1-5]\d{2}-?\d{4}-?\d{4}-?\d{4}$/",
        'discover'          =>    "/^6011-?\d{4}-?\d{4}-?\d{4}$/",
        'amex'              =>    "/^3[4,7]\d{13}$/",
        'diners'            =>    "/^3[0,6,8]\d{12}$/",
        'bankcard'          =>    "/^5610-?\d{4}-?\d{4}-?\d{4}$/",
        'jcb'               =>    "/^[3088|3096|3112|3158|3337|3528]\d{12}$/",
        'enroute'           =>    "/^[2014|2149]\d{11}$/",
        'switch'            =>    "/^[4903|4911|4936|5641|6333|6759|6334|6767]\d{12}$/"
    );

    $type = false;

    if (preg_match($cardtype['visa'], $number)) {
        $type = "visa";
    } else if (preg_match($cardtype['mastercard'], $number)) {
        $type = "mastercard";
    } else if (preg_match($cardtype['amex'], $number)) {
        $type = "amex";
    } else if (preg_match($cardtype['diners'], $number)) {
        $type = 'diners';
    } else if (preg_match($cardtype['bankcard'], $number)) {
        $type = 'bankcard';
    } else if (preg_match($cardtype['jcb'], $number)) {
        $type = 'jcb';
    } else if (preg_match($cardtype['enroute'], $number)) {
        $type = 'enroute';
    } else if (preg_match($cardtype['switch'], $number)) {
        $type = 'switch';
    } else {
        $type =  false;
    }

    $return['valid']    =    LuhnCheck($number);
    $return['ccnum']    =    $number;
    $return['type']     =    $type;

    return $return;
}

Essa função utiliza o Algoritmo de Luhn para fazer o checksum dos números do cartão retornando TRUE ou FALSE.

  • time_ago()
/**
 * time_ago
 *
 * Recebe um Timestamp e retorna o tempo que passou desta data até o momento atual.
 * 
 * @param  Integer $time
 * @return boolean
 */

function time_ago($time){
    $time_difference = time() - $time;
    if ($time_difference < 1) {
        return 'less than 1 second ago';
    }
    $condition = array(
        12 * 30 * 24 * 60 * 60 =>  'year',
        30 * 24 * 60 * 60       =>  'month',
        24 * 60 * 60            =>  'day',
        60 * 60                 =>  'hour',
        60                      =>  'minute',
        1                       =>  'second'
    );
    foreach ($condition as $secs => $str) {
        $d = $time_difference / $secs;
        if ($d >= 1) {
            $t = round($d);
            return 'about ' . $t . ' ' . $str . ($t > 1 ? 's' : '') . ' ago';
        }
    }
}
  • hextorgba()
/**
 * hextorgba
 *
 * Recebe uma string referente a um valor hexadecimal, um valor de transparencia entre 0-1 e converte para RGBA.
 * 
 * @param  String $hex
 * @param  Float $transp
 * @return boolean
 */
function hextorgba($hex, $transp = 1) {
    list($r, $g, $b) = sscanf($hex, "#%02x%02x%02x");
    echo 'rgba(' . $r . ',' . $g . ',' . $b . ', ' . $transp . ')';
}

Assets

Defina a source de todos os import .js e .css em application/config/assets.php

  • No array $config['default'] configure a ordem, da esquerda para a direita, em que os assets serão carregados. Note que os arquivos functions.js e style.css devem ser carregados por último. É válido freezar que os assets apenas serão carregados caso sejam definidos nesse array.
$config['default'] = ['bootstrap', 'vendors', 'toastr', 'custom'];

O $config["default"] é o array responsável por definir quais e em qual ordem os assets serão importados.

O indice custom deve estar sempre na última posição do vetor.

  • Defina o caminho dos plugins a serem utilizados sempre respeitando a estrutura dos arrays(como no exemplo a seguir) e adicionando o nome deste ao $config['default'](como mostrado a cima).
$config['modulo_name'] = [
    'css'   =>  [
        site_url('assets/path/to/css/file1.css'),
        site_url('assets/path/to/css/file2.css'),
        site_url('assets/path/to/css/file3.css'),
        site_url('assets/path/to/css/file4.css')
    ],
    'js'    =>  [
        site_url('assets/path/to/js/file1.js'),
        site_url('assets/path/to/js/file2.js'),
        site_url('assets/path/to/js/file3.js'),
        site_url('assets/path/to/js/file4.js')
    ]
];

Carregado por padrão(bootstrap e toastr)

Note que o Jquery não é carregado nos assets, visto que se carrega-lo ao final do documento, não será possível utiliza-lo no meio do <body>, então carrego o jquery 3.4.1 no da view application/views/master.php

// Bootstrap 4.3.1
$config['bootstrap'] = [
    'css' => [ 
        'https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css',
        site_url('assets/vendors/bootstrap-datepicker-1.9.0-dist/css/bootstrap-datepicker.min.css')
    ],
    'js'  => [
        'https://unpkg.com/popper.js/dist/umd/popper.min.js',
        'https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js',
        site_url('assets/vendors/bootstrap-datepicker-1.9.0-dist/js/bootstrap-datepicker.min.js')
    ]
];
// Toastr notification
$config['toastr'] = [
    'css'   =>  [
        site_url('assets/vendors/toastr/toastr.min.css')
    ],
    'js'    =>  [
        site_url('assets/vendors/toastr/toastr.min.js')
    ]
];


/**
 * ====================================
 * ADICIONAR OS PLUGINS NO ARRAY ABAIXO
 * ====================================
 */

// Plugins localizados na pasta assets/vendors
$config['vendors'] = [
    'css' => [

    ],

    'js' => [

    ]
];

// Ultimo módule a ser carregado
$config['custom'] = [
    'css' => [  
        site_url('assets/css/style.css'),
    ],
    'js' => [ 
        site_url('assets/js/functions.js'),         
    ]
];

Essa $config é carregada no método construtuor do Template Para exibir os css/js são utilizados as funções print_css() e print_js() do Template

Biblioteca Template

Essa classe tem como função principal auxiliar no fluxo MVC e possue métodos para carregar os assets(módulos), renderizar views, definir o title da página e carregar informações do Controller => View.

class Template {

    // instancia do codeigniter
    public $ci;

    // arquivos de css para carregar na página
    public $css;

    // arquivos de js para carregar na página
    public $js;

    // as views que serão carregadas
    public $views = array();

    // modulos para carregar
    public $modules = array();

    // adiciona uma variavel a ser carregada na view
    public $data = array();

    // pagina a ser carregada
    public $p_page = 'home';

    // guard
    public $guard;

    // titulo da pagina
    public $title = '';

    // método construtor
    public function __construct() {

        // pega a instancia do ci
        $this->ci =& get_instance();

        // pega a biblioteca de configuração
        $this->ci->config->load( 'assets' );

        // pega a biblioteca de guard
        $this->ci->load->library( 'Guard' );
        $this->guard = $this->ci->guard;

        // carrega os módulos padrão
        $this->loadDefault();
    }
}

Métodos

  • set_title()
  • print_title()
  • loadDefault()
  • use_module()
  • loadModules()
  • set()
  • item()
  • addCss()
  • addJs()
  • print_js()
  • print_css()
  • view()
  • print_view()
  • page()
  • print_component()
  • print_page()
  • render()

Não explicarei todos os métodos, pois muitos deles são apenas funções auxiliares e acabam nunca sendo utilizadas na prática pelo desenvolvedor.

Métodos principais

  • set()
    /**
     * set
     *
     * seta o valor para uma variavel
     * 
     * @param String $chave
     * @param String $valor
     * @return void
     */
    public function set( $chave, $valor ) {
        $this->data[$chave] = $valor;
    }

Essa função deve ser utilizada nos controllers para enviar informação para as views

Exemplo

class Usuario extends MY_Controller {

    public function __construct() {
        parent::__construct();
        $this->load->model('Usuarios_model');
    }

    public function index(){
        $usuarios = $this->Usuarios_model->getAll(); // busca todos os usuarios no bd
        $this->template->set("usuarios", $usuarios); // seta os usuarios ($usuarios) encontrados para a posição 'usuarios' do array do template
    }
}
  • item()
    /**
     * item
     *
     * pega o valor de uma varivel
     * 
     * @param  String
     * @return mixed [Retorna o objeto do array indicado pela $chave ou null caso não exista]
     */
    public function item( $chave ) {
        return ( isset( $this->data[$chave] ) ) ? $this->data[$chave] : null;
    }

Essa função deve ser utilizada nas views para recuperar informações enviadas pelo controller.

Exemplo

$usuarios = $this->template->item('usuarios'); //Armazena em $usuarios os dados adicionados anteriormente no controller

foreach ($usuarios as $user) {
    echo $user['nome'] . '<br>';
}
  • set_title()
    /**
     * set_title
     *
     * Define o titulo da página html
     * 
     * @param String $title [Titulo da página]
     * @return void
     */
    public function set_title( $title ) {
        $this->title = $title;
    }

Essa função deve ser utilizada nos controllers para definir o título da página que será carregada.

Exemplo

class Home extends MY_Controller {

    public function __construct() {
        parent::__construct();
    }

    public function index(){
        $this->template->set_title("Página inicial"); // Seta o titulo da pagina
    }
}
  • print_title()
    /**
     * print_title
     *
     * Exibe o titulo atual
     * 
     * @return void
     */
    public function print_title() {
        echo $this->title;
    }

Essa função deve ser utilizada nas views para printar o titulo da página uma vez que este tenha sido definido no controller pela função set_title. Deve ser chamada na view master.php a qual carrega a estrutura do HTML.

Exemplo

<!DOCTYPE html>
<html lang="pt-br">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <!-- Meta, title, CSS, favicons, etc. -->
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta http-equiv="Content-Language" content="pt-br">
  
        <!-- TITLE -->
        <title><?PHP $template->print_title(); ?></title> <!-- Exibe na tela o title setado no controller -->
        .
        .
        .
  • print_js()
    /**
     * print_js
     *
     * Imprime o js
     * 
     * @return void
     */
    public function print_js() {
        if(count($this->js) > 0){
            foreach( $this->js as $js ) {
                if(ENVIRONMENT == 'production')
                echo '<script src="'.$js.'" type="text/javascript"></script>';
                else{
                    echo '<script src="'.$js.'?version='.time().'" type="text/javascript"></script>';
                }
            }
        }
    }

Essa função deve ser utilizada nas views para imprimir na tela os arquivos JS definidos nos Assets. Deve ser chamada na view master.php a qual carrega a estrutura do HTML.

Exemplo

        .
        .
        .
        <!-- PRINT JS - CONFIG IN config/assets.php -->
        <?php $template->print_js(); ?>
    </body>
</html>
  • print_css()
    /**
     * print_css
     *
     * Imprime o css
     * 
     * @return void
     */
    public function print_css() {
        if(count($this->css) > 0){
            foreach( $this->css as $css ) {
                if(ENVIRONMENT == 'production'){
                    echo '<link href="'.$css.'" rel="stylesheet" media="screen"/>';
                }
                else{
                    echo '<link href="'.$css.'?version='.time().'" rel="stylesheet" media="screen"/>';   
                }
                
            }
        }
    }

Essa função deve ser utilizada nas views para imprimir na tela os arquivos CSS definidos nos Assets. Deve ser chamada na view master.php a qual carrega a estrutura do HTML.

Exemplo

<!DOCTYPE html>
<html lang="pt-br">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <!-- Meta, title, CSS, favicons, etc. -->
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta http-equiv="Content-Language" content="pt-br">
        
        <title><?PHP $template->print_title(); ?></title> <!-- Exibe na tela o title setado no controller -->


        <?PHP $template->print_css(); ?>

    </head>
    .
    .
    .

Note que nas funções print_css e print_js possuem uma verificação de ENVIRONMENT a qual define o estágio que está o projeto, possuindo os valores: production, testing e development. Quando não estivermos em ambiente de produção, a URL do arquivo recebe um sufixo ?version='.time().', para que o navegador seja sempre forçado a baixar o arquivo evitando problemas de cache.

  • print_component()
    /**
     * page
     *
     * carrega um componente
     * 
     * @param  String
     * @param Array $var [Array de dados a serem enviados para a view]
     * @return void
     */
    public function print_component( $component , $var = false) {
        
        // carrega a pagina
        $this->ci->load->view( 'components/'.$component, $var);
    }

Essa função deve ser utilizada nas views para imprimir um componente existente em application/views/components/

  • print_page()
    /**
     * print_page
     *
     * Carrega uma view salva em views/pages/[view].php
     * 
     * @param  String
     * @return void
     */
    public function print_page( $page = false ){

        // verifica se o usuário deseja carregar uma pagina em especifico
        $this->p_page = $page ? $page : $this->p_page;

        // carrega a pagina
        $this->ci->load->view( 'pages/'.$this->p_page );
    }

Essa função deve ser utilizada nas views para imprimir uma página existente em application/views/pages/

  • render()

Deve ser utilizado como um substituto do $this->load->view() do codeigniter para carregar páginas completas, dê uma olhada na view master para entender melhor o fluxo de carregamento.

    /**
     * render
     *
     * Renderiza a página escolhida em um layout escolhido (master.php)
     * 
     * @param  String $layout
     * @param  String $page
     * @return void
     */
    public function render( $layout = false, $page = false ) {

        // carrega os modulos
        $this->loadModules();

        // verifica se o usuário deseja carregar uma pagina em especifico
        $this->p_page = $page ? $page : $this->p_page;

        // carrega a view
        $this->ci->load->view( $layout, [ 'template' => $this ] );
    }

Essa função deve ser utilizada nos controllers para exibir uma página existente em application/views/pages/ dentro do layout application/views/master.php com seus respectivos módulos de css/js.

Exemplo

class Home extends MY_Controller {

    public function __construct() {
        parent::__construct();
    }

    public function index(){
        $this->template->set_title("Página inicial"); // Seta o titulo da pagina
        $this->template->render('master', 'home'); // Carrega a view /views/pages/home.php dentro do layout views/master.php
    }
}

Biblioteca Guard

Essa classe tem como função facilitar a manipulação da variável de sessão do usuário, utiliza-se as funções do Session Library do Codeigniter.

É restrito apenas à sessão de usuário ($_SESSION['user'] ou $this->session->user);

class Guard {

    // instancia do codeigniter
    public $ci;

    // dados do usuario logado
    public $user = false;

    // método construtor
    public function __construct() {

        // pega a instancia do ci
        $this->ci =& get_instance();

        // carrega a librarie de sessao
        $this->ci->load->library( 'session' );

        // pega os dados do usuario
        if ( $user = $this->ci->session->userdata( 'user' ) ) {
            $this->user = $user;
        }
    }

Métodos

  • logged()
    /**
     * logged
     *
     * Verifica se o usuário está logado ou não
     * 
     * @return Boolean
     */
    public function logged(){
        return $this->user ? true : false;
    }

Exemplo

if($this->guard->logged()){
  echo 'Usuário logado';
}
else{
  echo 'Usuário deslogado';
}
  • item()
    /**
     * item
     *
     * Retorna um item do array $user salvo na sessão
     * 
     * @param  String $key [Campo do array $user]
     * @return Object or NULL
     */
    public function item( $key ) {
        return isset( $this->user[$key] ) ? $this->user[$key] : null;
    }

Exemplo

$nome = $this->guard->item('nome');
echo $nome;
// Fulano da Silva
  • login()
    /**
     * login
     *
     * Tenta fazer o login do usuario através de um e-mail e senha inseridos
     * 
     * @param  String $email [E-mail para logar]
     * @param  String $senha [Senha para logar]
     * @return Boolean
     */
    public function login( $email, $senha ) {

        // carrega a model de usuários
        $this->ci->load->model( 'Usuarios_model' );

        // faz o login
        if ( $user = $this->ci->Usuarios_model->validate( $email ) ) {
            
            // Valida a senha do usuário
            // Para cadastrar a senha no banco utilize a função password_hash() do PHP
            if(password_verify($senha, $user['senha'])){        
                // guarda na sessao
                $this->ci->session->set_userdata( 'user', $user );            
                
                // guarda no atributo
                $this->user = $user;
                
                return true;
            }
        }
        
        return false;
    }

Percebam que nessa função é utilizado o método validate() do model de Usuarios. Essa função é responsável por fazer a busca através do email e da senha informados como parâmetros e retornar as tuplas referente ao usuário buscado ou false caso não encontre. Outro ponto importante é que deve ser utilizado hash para criptografar as senhas, sendo necessário o uso da função password_hash para inserir a senha no banco e password_verify para validar a senha no momento do login.

Exemplo

$email = 'fulano@example.com';
$senha = '123456';

if($this->guard->login($email, $senha)){
    echo 'Bem-vindo!';
}
else{
    echo 'Credenciais inválidas';
}
  • update()
    /**
     * update
     *
     * Busca o usuario no banco de dados e atualiza a sessão com os dados 'novos'
     * 
     * @return Boolean
     */
    public function update() {

        // verifica se existe um usuário logado
        if ( !$this->user ) return false;

        // carrega a model de usuários
        $this->ci->load->model( 'Usuarios_model' );

        // pega os dados do perfil do usuario logado
        if ( $user = $this->ci->Usuarios_model->getById( $this->user['id_usuario'] ) ) {

            // seta a sessao
            $this->ci->session->set_userdata( 'user', $user );

            // seta o usuario
            $this->user = $user;

            return true;

        } else return false;
    }

Exemplo

echo $this->guard->item('nome'); // Fulano da Silva

$dados = ['id' => $id_usuario, 'nome' => 'Bernardo'];  //Seta os dados para o update

$this->Usuarios_model->update($dados); // Atualiza o nome do usuario com id = $id_usuario

echo $this->guard->item('nome'); // Fulano da Silva

$this->guard->update(); // Atualiza a sessão com os valores do banco

echo $this->guard->item('nome'); // Bernardo
  • getShortName()
    /**
     * getShortName
     *
     * @param String $nome [Nome completo do usuario]
     * @return String [Concatena o primeiro e o ultimo nome do usuario]
     */
    public function getShortName($nome = false){
        if(!$nome)
            $nome = $this->user['nome'];

        $nomes = explode(" ", $nome);

        if(count($nomes) > 1)
            $nome = $nomes[0] . " " . $nomes[count($nomes)-1];        
        else
            $nome = $nomes[0];

        return $nome;
    }

Exemplo

echo $this->guard->item('nome'); // Fulano da Silva

echo $this->guard->getShortName(); // Fulano Silva

echo $this->guard->getShortName('Fulano de Oliveira da Silva'); // Fulano Silva
  • logout()
    /**
     * logout
     *
     * Limpa a sessão 'user'
     * 
     * @return void
     */
    public function logout() {
        $this->ci->session->unset_userdata('user');
    }

Exemplo

$this->guard->logout();

Core MY_Controller

Localizado em application/core/MY_Controller.php

Essa classe acaba sendo mais simples, pois cada controller é muito específico. Contudo é no método construtor que carregamos as bibliotecas Template e Guard.

Todos os controllers devem herdar o MY_Controller através da palavra chave extends do PHP.

class MY_Controller extends CI_Controller {
    
    // médoto construtor
    public function __construct() {
        parent::__construct();
     
        // Carrega o Template e Guard
        $this->load->library( 'Template' );
        $this->load->library( 'Guard' );
    }
}

Core MY_Model

Localizado em application/core/MY_Model.php

Essa classe é responsável por permitir a reutilização de funções que são comuns em aplicações web que utilizam SQL para manipular um banco de dados.

Nota: O MY_Model não substitui o Query Builder, então se você tem que usar alguma query complexa, não utilize o MY_Model para isso.

class MY_Model extends CI_Model {
    
    /**
    * table
    *
    * nome da tabela no model
    *
    * @protected
    */
    protected $table;

    /**
    * table_id
    *
    * chave da tabela no model
    *
    * @protected
    */
    protected $table_id;

    public function __construct() {
        parent::__construct();
    }
}

Basicamente a mágica acontece ao utilizar-se do conceito de herança da Programação Orientada a Objetos. Dessa forma os models a serem criados pelo desenvolvedor devem herdar essa classe através da palavra chave extends.

O $table(nome da tabela) e $table_id(chave primária) são atributos essenciais para isso, pois ambas representam as variáveis de qualquer consulta SQL básica, dessa forma podemos reutilizar funções como create, update e delete que ja existem no CI e além disso criar algumas novas como getAll() ou getAllLimit() para todos os models básicos.

É obrigatório a inicialização destas variáveis em todos os models que herdarem esta classe.

  • Exemplo Model para tabela de usuarios cuja a chave primária é id_usuario
class Usuarios_model extends MY_Model {

    /**
    * table
    *
    * nome da tabela no model
    *
    * @protected
    */
    protected $table = 'usuarios';

    /**
    * table_id
    *
    * chave da tabela no model
    *
    * @protected
    */
    protected $table_id = 'id_usuario';

    // metodo construtor
    public function __construct() {
        parent::__construct();
    }
}

Métodos

  • create()
   /**
   * create
   * 
   * insere um novo dado
   *
   * @param Array $dados [Dados a serem inseridos na tabela]
   * @return Boolean [Retorna true caso os dados tenham sido inseridos e false caso contrario]
   */
   public function create( $dados ){
       return $this->db->insert( $this->table, $dados );
   }

Exemplo

$this->load->model('Usuarios_model');

$dados = [
   'nome'          => 'Fulano da Silva',
   'email'         => 'fulano@example.com',
   'senha'         => '123456',
   'sexo'          => 'masculino',
   'data_nasc'     => '1996-04-03'
]; 

if($this->Usuarios_model->create($dados)){
   echo 'Usuário cadastrado com sucesso!';
}
else{
   echo 'Houve um erro no servidor.';
}
  • update()
  /**
   * update
   * 
   * atualiza um dado
   *
   * @param Array $dados [Dados a serem atualizados. *O campo 'id' deve ser passado obrigatoriamente]
   * @return Boolean [Retorna true caso os dados tenham sido atualizados e false caso tenha algum erro de lógica no SQL]
   */
   public function update( $dados ) {

       // prepara os dados
       $this->db->where( $this->table_id, $dados['id']);

       // deleta o id
       unset( $dados['id'] );
       if ( isset( $dados[$this->table_id] ) ) unset( $dados[$this->table_id] );

       // faz o update
       return $this->db->update($this->table, $dados); 
   }

O campo id do array é obrigatório

Exemplo

$this->load->model('Usuarios_model');

$dados = [
    'id'            => 1,
    'nome'          => 'Fulano da Silva',
    'email'         => 'fulano@example.com',
    'senha'         => '123456',
    'sexo'          => 'masculino',
    'data_nasc'     => '1996-04-03'
]; 

if($this->Usuarios_model->update($dados)){
    echo 'Usuário atualizado com sucesso!';
}
else{
    echo 'Houve um erro no servidor.';
}

Perceba que não importa o nome da sua chave primária, o array com dados para update deve sempre conter um campo chamado id!

  • delete()
  /**
   * delete
   * 
   * deleta um dado
   *
   * @param mixed $id [Chave primária da tabela]
   * @return Boolean [Retorna true caso remova a linha ou false caso contrario]
   */
   public function delete( $id ) {
       $this->db->where( $this->table_id, $id );
       return $this->db->delete( $this->table ); 
   }

Exemplo

$this->load->model('Usuarios_model');

if($this->Usuarios_model->delete(1)){
    echo 'Usuário deletado com sucesso!';
}
else{
    echo 'Houve um erro no servidor.';
}
  • getById()
   /**
   * getById
   * 
   * pega um dado por id
   *
   * @param  $id [Chave primária da tabela]
   * @return mixed [Retorna um array com os dados requisitados ou false caso não encontre nada]
   */
   public function getById( $id ){
       
       // faz a busca
       $this->db->select( '*' )
       ->from( $this->table )
       ->where( [$this->table_id => $id ] );
       $query = $this->db->get();

       // verifica se existem resultados
       return ( $query->num_rows() > 0 ) ? $query->result_array()[0] : false;
   }

Exemplo

$this->load->model('Usuarios_model');

$user = $this->Usuarios_model->getById(1);

if($user){
    echo $user['nome']; //Fulano da Silva
}
else{
    echo 'Usuário não encontrado';
}
  • getAll()
   /**
   * getAll
   * 
   * pega todos os registros
   *
   * @param mixed $where [Opcional: Condições da consulta]
   * @param String $fields [Opcional: Campos do SELECT da consulta]
   * @param mixed $orderby [Opcional: Ordenação da consulta]
   * @return mixed [Retorna a coleção de dados requisitadas em uma matriz]
   */
   public function getAll( $where = false, $fields = '*', $orderby = false) {
       
       if($orderby){
           $orderby = explode(" ", $orderby);
           $order = $orderby[1];
           $order_colum = $orderby[0];
       }
       else{
           $order = 'asc';
           $order_colum = $this->table_id;
       }

       // monta a busca
       $this->db->select( $fields );
       $this->db->from( $this->table );

       //verifica se existe um where
       if ( $where ) $this->db->where( $where );

       $this->db->order_by($order_colum, $order);

       // pega os dados do banco
       $query = $this->db->get();

       // verifica se existem resultados
       return ( $query->num_rows() > 0 ) ? $query->result_array() : false;
   }

Exemplo 1:

$this->load->model('Usuarios_model');

$users = $this->Usuarios_model->getAll(); // Busca todas as tuplas da tabela `usuarios`

if($users){
    foreach ($users as $user) {
        echo $user['nome'] . '<br>';
    }
}
else{
    echo 'Usuário não encontrado';
}

Exemplo 2:

$this->load->model('Usuarios_model');

$users = $this->Usuarios_model->getAll('sexo = masculino', 'usuarios.nome', 'nome asc'); // Será feita a consulta na tabela `usuarios` atrás das tuplas que possuem o sexo definido como masculino e retornará todos os nomes em ordem crescente.

if($users){
    foreach ($users as $user) {
        echo $user['nome'] . '<br>';
    }
}
else{
    echo 'Usuário não encontrado';
}

Exemplo 3:

$this->load->model('Usuarios_model');

$users = $this->Usuarios_model->getAll(false, 'usuarios.nome', 'nome asc'); // Será feita a consulta na tabela `usuarios` e retornara todos os nomes dos usuarios ordenados pelo nome crescente.

if($users){
    foreach ($users as $user) {
        echo $user['nome'] . '<br>';
    }
}
else{
    echo 'Usuário não encontrado';
}
  • getAllLimit()
   /**
    * getAllLimit
    * 
    * @param int $limit [Inteiro que define a quantidade máxima de resultados da consulta]
    * @return Array[] [Retorna a coleção de dados requisitadas em uma matriz]    
    * 
    */
   public function getAllLimit($limit){
       $this->db->from($this->table)
       ->select('*')
       ->limit($limit);

       $busca = $this->db->get();

       return ($busca->num_rows() > 0) ? $busca->result_array() : array();

   }

Exemplo

$this->load->model('Usuarios_model');

$users = $this->Usuarios_model->getAllLimit(5); // Será feita a consulta na tabela `usuarios` e retornará as 5 primeiras linhas.

if($users){
    foreach ($users as $user) {
        echo $user['nome'] . '<br>';
    }
}
else{
    echo 'Usuário não encontrado';
}

Esta função foi feita apenas para auxiliar no desenvolvimento da aplicação, dificilmente você usará ela em produção. Deve ser utilizada quando você queira testar uma listagem de dados e possa limitar a quantidade de resultados, porém sem poder filtra-los.

Notificações

O sistema de notificações deste template utiliza a biblioteca javascript Toastr juntamente com a função nativa do Codeigniter SESSION Flashdata.

Utilizaremos a função notifyUser() para exibir as notificações através do javascript.

/**
* notifyUser
* 
* notifica o usuario
*
* @param String type [Tipo de notificação]
* @param String text [Conteúdo da notificação]
* @param Int delay [Tempo para a notificação sumir]
*/
function notifyUser(type, text, delay = 8000) {
    var icon = "";
    var title = "";

    // Toastr config
    toastr.options = {
        "closeButton": false,
        "debug": false,
        "newestOnTop": false,
        "progressBar": true,
        "positionClass": "toast-top-right",
        "preventDuplicates": true,
        "onclick": null,
        "showDuration": 300,
        "hideDuration": 1000,
        "timeOut": delay,
        "extendedTimeOut": 1000,
        "showEasing": "swing",
        "hideEasing": "linear",
        "showMethod": "fadeIn",
        "hideMethod": "fadeOut"
    }

    switch(type){
      case 'success':
        toastr.success(text);
      break;

      case 'error':
        toastr.error(text);
      break;

      case 'warning':
        toastr.warning(text);
      break;

      case 'info':
        toastr.info(text);      
      break;

      case 'loading':
        icon = "<i class='fa fa-spin fa-spinner'></i>&ensp;";
        
        toastr.options.timeOut = 0;
        toastr.options.extendedTimeOut = 0;

        toastr.info("<i class='fa fa-spin fa-spinner'></i>&ensp;" + text);
        
      break;

      default:
        toastr.error('Houve um erro ao exibir a notificação');
      break;
    }

};

Para trazermos notificações de um Controller para uma View após realizarmos um redirect utilizaremos o conceito de SESSION FLASHDATA, o qual permite armazenar informações válidas somente na próxima requisição e após isso serão apagadas automaticamente.

Exemplo de como criar uma notificação no Controller.

public function login(){
    $post = $this->input->post();

    if($this->guard->login($post['email'], $post['senha'])){
        $this->session->set_flashdata('success', 'Bem vindo!');
    }
    else
        $this->session->set_flashdata('error', 'Credenciais inválidas.');

    redirect(site_url(),'location');
}

O arquivo application/views/components/alerts.php contém a ligação entre o PHP e o Javascript:

<?php if($this->session->flashdata('success')): ?>
    <script>
        $(document).ready(function(){
            notifyUser('success', '<?php echo $this->session->flashdata('success') ?>');
        });
    </script>
<?php endif; ?>


<?php if($this->session->flashdata('error')): ?>
    <script>
        $(document).ready(function(){
            notifyUser('error', '<?php echo $this->session->flashdata('error') ?>');
        });
    </script>
<?php endif; ?>

<?php if($this->session->flashdata('warning')): ?>
    <script>
        $(document).ready(function(){
            notifyUser('warning', '<?php echo $this->session->flashdata('warning') ?>');
        });
    </script>
<?php endif; ?>

<?php if($this->session->flashdata('info')): ?>
    <script>
        $(document).ready(function(){
            notifyUser('info', '<?php echo $this->session->flashdata('info') ?>');
        });
    </script>
<?php endif; ?>


<?php if($this->session->flashdata('loading')): ?>
    <script>
        $(document).ready(function(){
            notifyUser('loading', '<?php echo $this->session->flashdata('loading') ?>');
        });
    </script>
<?php endif; ?>

A função notifyUser() está definida em assets/js/functions.js

Existem duas formas de se exibir uma notificação para o usuário

  • PHP

No controller, antes do redirect(), deve-se criar uma session flashdata com o índice definido como sendo um dos cinco tipos citados abaixo.

$this->session->set_flashdata('success', 'Muito bom, sua ação foi concluída com sucesso!');
  • Javascript

Em qualquer view basta chamar a função notifyUser passando como primeiro parâmetro o tipo da notificação e segundo a mensagem que desejar.

notifyUser('success', 'Muito bom, sua ação foi concluída com sucesso!');

Existem cinco tipos de notificações pré-definidas: success, error, warning, info e loading.

  • success:

Deve ser utilizada para notificações de sucesso.

  • error:

Deve ser utilizada para notificações de erros ou falhas do sistema

  • warning:

Deve ser utilizada para notificações de atenção ao usuário

  • info:

Deve ser utilizada para dar informações extras ao usuário

  • loading:

Deve ser utilizada para funções que utilizem ajax chamando a função notifyUser na beforeSend() para que passe para o usuário a sensação de que algo está acontecendo visto que o ajax é dinâmico e não é percebido pelo usuário final.

Exemplo de notificação loading:

$.ajax({
    url: '/path/to/file',
    type: 'POST',
    dataType: 'json',
    data: data,
    beforeSend: function(){
        notifyUser('loading', 'Carregando informações...');
    }
})
.done(function(response) {
    PNotify.removeAll(); //Remove todas as notificações

    console.log("success");
})
.fail(function(xhr, status) {
    console.log("error");
})
.always(function() {
    console.log("complete");
});
  • Remover as notificações ativas

Para fazer com que as notificações desapareçam basta usar a função do Toastr:

toastr.clear();

Plugins JS

Localizados em assets/vendors/

Contribuição

Desenvolvido por Bernardo Camargo @bernacamargo

Licença

MIT