Documentação do Webservice

Conjunto de caracteres

Por padrão, todos os arquivos do webservice são escritos em Charset UTF8

Configuração do ambiente

Script de Configurações deve estar localizado em config/System.config.php

Fluxo da aplicação

fluxo-bp
index.php -> App -> RouteMap_Config -> Controller -> *
Todas as requisições devem passar pelo script index.php, este arquivo é responsável por:

  • Instânciar a classe App
    • Ao construir, carrega no sistema as classes básicas necessárias para executar uma requisição. (Util, Basic, Model, DAO, Permissions…)
    • Acessa o RouteMap_Config
      • Analisa a rota da requisição
      • Verifica a classe de configurações de rota
      • Encontra e executa o controller relacionado a rota

Estrutura de Pastas e Arquivos do Webservice

  • config – diretório com arquivos de configuração
  • controller – diretório com as classes controllers
  • dao – diretório com as classes DAO
  • específicos – diretório com classes específicas da implantação
  • job – diretório com as classes JOB
  • log – diretório com os logs do webservice
  • mail – diretório com as classes Mail
  • model – diretório com as classes Model
  • pdf – diretório com as classes PDF
  • pe – diretório com scripts de ponto de entrada
  • peJS – diretório com scripts de ponto de entrada que serão executados no frontend (javascript)
  • sys – diretório com classes e scripts

Classe Basic

Utilizada como base para as classes de Controller, DAO, Model, etc.

static function instance_token()

Retorna o token da sessão definido no header da requisição

static function LoadModel($model_class_required, $auto_construct=false)

Carrega o arquivo da classe do model.

Parâmetro Descrição
$model_class_required Nome do model a ser carregado
$auto_construct Caso true, o retorno da função será um objeto model instanciado

Retorna null ou o objeto o model

static function LoadDAO($dao_class_required, $auto_construct=false)

Carrega o arquivo da classe do DAO.

Parâmetro Descrição
$dao_class_required Nome do DAO a ser carregado
$auto_construct Caso true, o retorno da função será um objeto DAO instanciado

Retorna null ou o objeto o model

static function LoadMail($mail_class_required, $auto_construct=false)

Carrega o arquivo da classe do Mail.

Parâmetro Descrição
$mail_class_required Nome da classe email a ser carregado
$auto_construct Caso true, o retorno da função será um objeto Email instanciado

static function LoadPDF($pdf_class_required, $auto_construct=false)

Carrega o arquivo da classe do PDF.

Parâmetro Descrição
$pdf_class_required Nome da classe pdf a ser carregado
$auto_construct Caso true, o retorno da função será um objeto PDF instanciado

static function LoadPE($pe_script_required)

Carrega o arquivo da classe do PE.

Parâmetro Descrição
$pe_script_required Nome do script de ponto de entrada a ser carregado

Classe BusinessException

Utilizado para disparar exceções de regras de negócio. Essa classe possui um objeto de validação que pode conter várias mensagens que serão formatadas no frontend.

Parâmetro Descrição
$validation Tipo de erro: Permissão, Token, SQL e etc…

A classe possui o atributo trace, ele contém a rota de scripts PHP que foram executados, possibilitando a localização do erro (debug).
Este recurso é habilitado automaticamente quando a requisição é local, caso seja necessário habilitar para requisição externa, alterar o arquivo System.config.php, adicionando a constante define(‘DEBUG_BUSINESS_EXEPTION’, IP), onde o IP informado deve do cliente que está fazendo a requisição.

Exemplo de validação:

$validation = new Validation();
$validation->add(Validation::VALID_ERR_NOT_EXISTS, 'Assunto não existe');
throw new BusinessException($validation);
Constante Valor Significado
Validation::VALID_ERR_FIELD 0 Campo inválido, utilizado em validação da modelagem
Validation::VALID_ERR_NOT_EXISTS 1 Não existe
Validation::VALID_ERR_TOKEN 2 Token inválido
Validation::VALID_ERR_PERMISSION 3 Permissão inválida
Validation::VALID_ERR_CON_DB 4 Falha de conexão com o banco
Validation::VALID_ERR_CON_DB_LIMIT_EXCEEDED 5 Limite de conexões excedidas com o banco de dados
Validation::VALID_ERR_DB_UNKNOWN 6 Database não existe no banco de dados
Validation::VALID_ERR_DB_HOST_UNKNOWN 7 Endereço do banco de dados não existe
Validation::VALID_ERR_DB_TABLE_UNKNOWN 8 Tabela não existe no banco de dados

Classe DB

A classe DB possui funções para interação com banco de dados. Exemplos:

  • Conexão com o banco de dados
  • Controle de transação (beginTransaction, commit, Rollback)
  • Executar de Instruções DML (insert, update, delete)
  • Funções de formatação dos dados para inserir no banco de dados (key_to_sql, check_to_sql)

static function getInstance()

Verifica se existe uma instância criada no banco de dados, caso contrário, é criada nova instância.
Retorno: Nova instância do banco de dados.

function connect($force=false)

Conexão com banco de dados MySQL utilizando PDO (biblioteca de conexão).

Parâmetro Descrição
$dns String de conexão: ‘mysql:host=’.DB_HOST. ‘: ‘.DB_PORT.’;dbname=’.DB_NAME.’;charset=utf8′
$user Usuário do banco de dados
$pass Senha
$conn Instânciar classe PDO: @new PDO($this->dns, $this->user, $this->pass);
$conn->setAttribute Tratamento de erros do PDO: PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION
$conn->exec Charset exemplo: set names utf8

static function query($sql, $params=null, $row_object=false)

Executa uma consulta SQL utilizando a conexão ativa. Utilizar para Selects.

Parâmetro Descrição
$sql String da consulta SQL
$params Array de parâmetros com seus valores
$row_object Se true, retorna um array de objetos, e não uma matriz

Exemplo:

$sql = "SELECT
        id AS area_id,
        excluido,
        insert_hora, update_hora, delete_hora,
        insert_usuario_id, update_usuario_id, delete_usuario_id,
        nome
        FROM
        area
        WHERE id = :id";

$params[':id'] = $area_id;

$query = DB::query($sql, $params);

print_r($query);

Conteúdo da $query:

Array
(
    [0] => Array
    (
        [area_id] => 4
        [excluido] => N
        [nome] => Administração
    )
)

Exemplo com $row_object = true:

$query = DB::query($sql, $params, true);
print_r($query);

Retorno:

Array
(
    [0] => stdClass Object
    (
        [area_id] => 4
        [excluido] => N
        [nome] => Administração
    )
)

static function exec($sql, $params=null)

Executa um comando SQL utilizando a conexão ativa. Utilizar para Inserts, updates, deletes.

Parâmetro Descrição
$sql String da execução SQL
$params Array de parâmetros com seus valores

Exemplo:

$sql = "INSERT INTO area (nome) VALUES (:nome) ";
$params[':nome'] = DB::string_to_sql($area_model->nome);
$query = DB::exec($sql, $params);

static function last_insert_id()

Obtém o último número gerado pelo auto incremento na conexão ativa.

Exemplo:

$sql = "INSERT INTO area (nome) VALUES (:nome) ";
$params[':nome'] = DB::string_to_sql($area_model->nome);
DB::exec($sql, $params);
$last_insert_id = DB::last_insert_id();
print($last_insert_id); // retorno 11 (id gerado automaticamente pelo insert)

static function begin_transaction()

Inicia uma transação na conexão ativa.

static function roll_back()

Cancela as execuções aplicadas após o início da transação. Encerra a transação.

static function commit()

Confirma as execuções aplicadas após o início da transação. Encerra a transação.

Exemplo:

DB::begin_transaction();

$sql_1 = "DELETE area WHERE id = :id ";
$params_1[':id] = 11;

// este SQL está incorreto propositalmente para para simular nosso exemplo
$sql_2 = "DELETE area WHERE id = :id ";
$params_2[':id] = 12;

try {
    DB::exec($sql_1, $params_1);
    DB::exec($sql_2, $params_2);

    DB::commit();
}
catch (BusinessException $e) {
    DB::roll_back();
}

static function in_transaction()

Verifica se existe uma transação ativa

Exemplo:

print(DB::in_transaction()); // retorna false
DB::begin_transaction();
print(DB::in_transaction()); // retorna true
DB::roll_back();
print(DB::in_transaction()); // retorna false

static function has_rows(&$array)

Verifica se o array possui conteúdo.

Exemplo:

if (DB::has_rows($query)) {
    // seu código
}

static function check_to_sql($val)

Converte valores strings ou booleano para S ou N, para ser utilizado no SQL.

Valor Descrição
true S
false N

Exemplo:

$valor = check_to_sql(true);
print($valor); // Resultado = S

$valor = check_to_sql(false);
print($valor); // Resultado = N

static function sql_to_check($val)

Converte uma string (S ou N) em booleano.

Exemplo:

$valor = sql_to_check('S');
print($valor); // Resultado true

$valor = sql_to_check('N');
print($valor); // Resultado false

static function key_to_sql($val)

Converte um valor para inteiro, se for 0 irá retornar null.

Exemplo:

$sql = 'INSERT INTO agenda_evento (usuario_id) VALUES (:usuario_id)';
$params[':usuario_id'] = DB::key_to_sql($agenda_evento_model->usuario_id);
$query = DB::exec($sql, $params);

static function time_to_sql($val)

Recebe uma string no formado hh:mm:ss e retorna hh:mm

Exemplo:

$calendario_trabalho_model->hora_inicio = '08:10:22';
$calendario_trabalho_model->hora_fim = '12:54:22';

$sql = "INSERT INTO calendario_trabalho (
    nome,
    hora_inicio,
    hora_fim
) VALUES (
    :nome,
    :hora_inicio,
    :hora_fim
)";

$params[':nome'] = DB::string_to_sql($calendario_trabalho_model->nome);
$params[':hora_inicio'] = DB::time_to_sql($calendario_trabalho_model->hora_inicio); // 08:10
$params[':hora_fim] = DB::time_to_sql($calendario_trabalho_model->hora_fim); // 12:54

static function string_to_sql($val, $empty_null=false)

Verifica se $val possui conteúdo, caso $empty_null seja false e o conteúdo vaziu, retorna null

$val $empty_null Retorno
‘Teste’ true/false ‘Teste’
‘’ false ‘’
‘’ true null

static function int_to_sql($val, $zero_null=false)

Verifica se $val possui conteúdo, caso $zero_null seja false e o conteúdo não seja inteiro maior que zero, retorna null

$val $zero_null Retorno
‘0123’ true/false 123
‘00’ false 0
‘00’ true null

Model

Regras:

  • A classe deve estar na pasta model
  • O nome do arquivo da classe deve ser Nome_Classe.model.php
  • O nome da classe deve ser o prefixo do nome do arquivo seguido de _Model
  • A classe deve ser herdada da classe Model

Exemplo:
Arquivo model/Usuario.model.php

<?php

use \Sys\Validation;

class Usuario_Model extends \Sys\Model
{
    const USUARIO_TIPO_CLIENTE = 1;
    const USUARIO_TIPO_COLABORADOR = 2;
    const USUARIO_TIPO_FORNECEDOR = 4;
    const USUARIO_TIPO_PROSPECT = 5;

    public $nome;
    public $email;
    public $senha;
    public $bloqueado;
    public $admin;
    public $area_id;
    public $calendario_trabalho_id;
    public $tipo;

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

    function validation() {

        $validation = new Validation();

        if (strlen($this->nome) == 0) {
            $validation->add(Validation::VALID_ERR_FIELD, 'Informe o nome');
        }

        if (strlen($this->email) == 0) {
            $validation->add(Validation::VALID_ERR_FIELD, 'Informe o e-mail');
        }

        if (strlen($this->senha) == 0) {
            $validation->add(Validation::VALID_ERR_FIELD, 'Informe a senha');
        }

        return $validation;
    }

}

Controller

Regras:

  • A classe deve estar na pasta controller.
  • O nome do arquivo da classe deve ser Nome_Classe.controller.php.
  • O nome da classe deve ser o prefixo do nome do arquivo seguido de _Controller.
  • A classe deve ser herdada da classe Controller.

Exemplo:
Arquivo controller/Assunto.controller.php

<?php

class Assunto_Controller extends \Sys\Controller
{
    function listar($url_params)
    {
        // valida token
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        // instâncio o assunto
        $assunto_dao = $this->LoadDAO('Assunto', true);

        try {
            $lista = $assunto_dao->listar();
            $this->print_json($lista);
        }
        catch (BusinessException $e) {
            $this->print_json($e);
        }
    }

    function objeto($url_params)
    {
        // valida token
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        // valida permissões
        \Sys\Permissions::verificar($sessao_model->dados->permissoes, 'assunto');

        // obtenho os parâmetros
        $assunto_id = (int)$this->ReadGet('assunto_id');

        // instâncio o assunto
        $assunto_model = $this->LoadModel('Assunto', true);
        $assunto_dao = $this->LoadDAO('Assunto', true);

        try {
            $assunto_model = $assunto_dao->popular($assunto_id);
            $this->print_json($assunto_model);
        }
        catch (BusinessException $e) {
            $this->print_json($e);
        }
    }

    function salvar($url_params)
    {
        // valida token
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        // valida permissões
        \Sys\Permissions::verificar($sessao_model->dados->permissoes, 'assunto');

        // obtenho os parâmetros
        $assunto_id = (int)$this->ReadPost('assunto_id');

        // instâncio o assunto
        $assunto_model = $this->LoadModel('Assunto', true);
        $assunto_dao = $this->LoadDAO('Assunto', true);

        try {
            if ($assunto_id > 0) {
                $assunto_model = $assunto_dao->popular($assunto_id);
            }

            $assunto_model->descricao = $this->ReadPost('descricao');
            $assunto_model->controle_acessos = $this->ReadPost('controle_acessos');

            $ret = $assunto_dao->salvar($assunto_model);

            $this->print_json($ret);
        }
        catch (BusinessException $e) {
            $this->print_json($e);
        }
    }

    function excluir($url_params)
    {
        // valida token
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);
        // valida permissões
        \Sys\Permissions::verificar($sessao_model->dados->permissoes, 'assunto');

        // obtenho os parâmetros
        $assunto_id = (int)$this->ReadPost('assunto_id');

        // instâncio o assunto
        $assunto_model = $this->LoadModel('Assunto', true);
        $assunto_dao = $this->LoadDAO('Assunto', true);

        try {
            $assunto_model = $assunto_dao->popular($assunto_id);
            $assunto_model = $assunto_dao->excluir($assunto_model);
            $this->print_json($assunto_model);
        }
        catch (BusinessException $e) {
            $this->print_json($e);
        }
    }
}

function RenderView($master_page, $view_file, array $data=array())

Utilizado para gerar páginas HTML através do PHP

Parâmetro Descrição
$master_page Página com o layout principal do site
$view_file View (html) que será carregada dentro da máster page
$data Array de dados que poderão ser acessados de dentro da View

function ReadPost($name, $default=null)

Utilizado para obter os posts da requisição

Parâmetro Descrição
$name Nome do parâmetro passado na requisição
$default Valor padrão que será atribuído caso o parâmetro não exista

function ReadGet($name, $default=null)

Utilizado para obter os gets da requisição

Parâmetro Descrição
$name Nome do parâmetro passado na requisição
$default Valor padrão que será atribuído caso o parâmetro não exista

function ReadRequest($name, $default=null)

Utilizado para obter os posts, gets ou cookies da requisição

Parâmetro Descrição
$name Nome do parâmetro passado na requisição
$default Valor padrão que será atribuído caso o parâmetro não exista

function ReadFile($name, $default=null)

Utilizado para obter um arquivo enviado pela requisição

Parâmetro Descrição
$name Nome do parâmetro do arquivo passado na requisição
$default Valor padrão que será atribuído caso o parâmetro não exista

Retorno $_FILES[$name] ou $default caso o parâmetro não exista.

function ReadFiles($name)

Utilizado para obter o array de arquivos enviados pela requisição

Parâmetro Descrição
$name Nome do parâmetro do arquivo passado na requisição

Retorno array de arquivos. Obs: estrutura diferente de $_FILES.

Array
(
    [0] => Array
    (
        [name] => 31160225953316000129550010000128821000035756.xml
        [type] => text/xml
        [tmp_name] => C:\Windows\Temp\php8032.tmp
        [error] => 0
        [size] => 7514
    )

    [1] => Array
    (
        [name] => Anotações.txt
        [type] => text/plain
        [tmp_name] => C:\Windows\Temp\php8033.tmp
        [error] => 0
        [size] => 1099
    )
)

function print_json($obj)

Retorna uma string representando objeto em JSON

Adiciona ao header da resposta da requisição “Content-type: application/json; charset=utf-8”

Obs: a função print_json também poderá ser acessada por App::print_json($obj)

DAO

Regras:

  • A classe deve estar na pasta dao
  • O nome do arquivo da classe deve ser Nome_Classe.dao.php
  • O nome da classe deve ser o prefixo do nome do arquivo seguido de _DAO
  • A classe deve ser herdada da classe DAO
  • Deve utilizar o namespace DB, para utilizar o BD
  • Nas query SQL nunca utilizar * para trazer colunas.
  • Geralmente por padrão nas classe Dao possuimos as funções listar, insert, salvar, update, excluir, popular, preencher, existe.

Obs:

  • Listar – Consulta todos os dados da query.
  • Insert – é chamada através da salvar, afim de validar se a informação está sendo atualizado ou inserida, isso depende da função existe
  • Update – Semelhante ao insert, porém esse recebe um id
  • Salvar – Responsável por verificar se a informação será salva ou inserida.
  • Excluir – Responsável por excluir os registros.
  • Popular – retorna um informações de um query especifica, e trabalha em conjunto com o preencher para trazer os valores para um model.
  • Existe – Valida se aquele registro existe, para verificar se deve atualizar ou inserir.

Exemplo:

Arquivo dao/Assunto.dao.php

<?php

use \Sys\DB;
use \Sys\Util;
use \Sys\Validation;

class Assunto_DAO extends \Sys\DAO {

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

    function salvar($assunto_model)
    {
        if (!$this->existe($assunto_model->id)) {
            return $this->insert($assunto_model);
        }
        else {
            return $this->update($assunto_model);
        }
    }

    function existe($assunto_id=0)
    {
        $sql = "SELECT id FROM assunto WHERE id = :id";
        $params[':id'] = $assunto_id;
        $query = DB::query($sql, $params);

        if (DB::has_rows($query)) {
            return true;
        }

        return false;
    }

    function insert($assunto_model)
    {
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        $validation = $assunto_model->validation();

        if (!$validation->isValid()) {
            throw new BusinessException($validation);
        }

        $sql = "INSERT INTO assunto (
            insert_hora,
            insert_usuario_id,
            descricao
            ) VALUES (
            :insert_hora,
            :insert_usuario_id,
            :descricao
        ) ";

        $params[':insert_hora'] = Util::DateNow();
        $params[':insert_usuario_id'] = $sessao_model->usuario_id;
        $params[':descricao'] = DB::string_to_sql($assunto_model->descricao);

        $query = DB::exec($sql, $params);

        // obtenho o id gerado
        $last_insert_id = DB::last_insert_id();
        $assunto_model->id = $last_insert_id;

        // recarrego os dados do objeto
        $assunto_model = $this->popular($last_insert_id);

        return $assunto_model;
    }

    function update($assunto_model)
    {
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);
        $validation = $assunto_model->validation();

        if (!$validation->isValid()) {
            throw new BusinessException($validation);
        }

        if (!$this->existe($assunto_model->id)) {
            $validation = new Validation();
            $validation->add(Validation::VALID_ERR_NOT_EXISTS, 'Assunto não existe');
            throw new BusinessException($validation);
        }

        $sql = "UPDATE
                    assunto
                SET
                    update_hora = :update_hora,
                    update_usuario_id = :update_usuario_id,
                    descricao = :descricao
                WHERE
                    id = :id ";

        $params[':update_hora'] = Util::DateNow();
        $params[':update_usuario_id'] = $sessao_model->usuario_id;
        $params[':descricao'] = DB::string_to_sql($assunto_model->descricao);

        //where
        $params[':id'] = $assunto_model->id;

        $query = DB::exec($sql, $params);

        // recarrego os dados do objeto
        $assunto_model = $this->popular($assunto_model->id);

        return $assunto_model;
    }


    function excluir($assunto_model) {
        
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        if (!$this->existe($assunto_model->id)) {
            $validation = new Validation();
            $validation->add(Validation::VALID_ERR_NOT_EXISTS, 'Assunto não existe');
            throw new BusinessException($validation);
        }

        // excluo o assunto
        $sql = "UPDATE
                    assunto
                SET
                    delete_hora = :delete_hora,
                    delete_usuario_id = :delete_usuario_id,
                    excluido = :excluido
                WHERE
                    id = :id ";


        $params = array();
        $params[':delete_hora'] = Util::DateNow();
        $params[':delete_usuario_id'] = $sessao_model->usuario_id;
        $params[':excluido'] = 'S';
        $params[':id'] = $assunto_model->id;

        $query = DB::exec($sql, $params);

        // recarrego os dados do objeto
        $assunto_model = $this->popular($assunto_model->id);

        return $assunto_model;
    }

    function popular($assunto_id) {

        if (!$this->existe($assunto_id)) {
            $validation = new Validation();
            $validation->add(Validation::VALID_ERR_NOT_EXISTS, 'Assunto não existe');
            throw new BusinessException($validation);
        }

        $sql = "SELECT
                    id AS assunto_id,
                    excluido,
                    insert_hora, update_hora, delete_hora,
                    insert_usuario_id, update_usuario_id, delete_usuario_id,
                    descricao
                FROM
                    assunto
                WHERE
                    id = :id";

        $params[':id'] = $assunto_id;
        $query = DB::query($sql, $params);

        return $this->preencher($query[0]);
    }

    function preencher($row_query) {

        if ($row_query) {
            $assunto_model = $this->LoadModel('Assunto', true);

            $assunto_model->id = (int)$row_query['assunto_id'];
            $assunto_model->excluido = DB::sql_to_check((string)$row_query['excluido']);
            $assunto_model->insert_hora = (string)$row_query['insert_hora'];
            $assunto_model->update_hora = (string)$row_query['update_hora'];
            $assunto_model->delete_hora = (string)$row_query['delete_hora'];
            $assunto_model->insert_usuario_id = (!empty($row_query['insert_usuario_id']) ? (int)$row_query['insert_usuario_id'] : null);
            $assunto_model->update_usuario_id = (!empty($row_query['update_usuario_id']) ? (int)$row_query['update_usuario_id'] : null);
            $assunto_model->delete_usuario_id = (!empty($row_query['delete_usuario_id']) ? (int)$row_query['delete_usuario_id'] : null);
            $assunto_model->descricao = (string)$row_query['descricao'];

            return $assunto_model;
        }

        return null;

    }

    function listar() {

        $sql = "SELECT
                    id AS assunto_id,
                    descricao
                FROM assunto

                WHERE excluido = 'N'

                ORDER BY descricao ";

        $query = DB::query($sql);

        return $query;
    }

}

Classe Permissions e Permissions_Config

Regras:

  • A classe Permissions possui o array de permissões e as funções necessárias para validar se uma permissão existe no array
  • A classe Permissions_Config herda a classe Permissions, na Permissions_Config é alimentado o array de permissões do usuário administrador.

static function verificar($permissoes, $chave_permissao=null)

Deve receber em $permissoes o array de permissões da sessão do usuário, $chave_permisao deve ser o nome da chave a ser verificada.

<?php

class Area_Controller extends \Sys\Controller
{

    function listar($url_params) {

        // valida token
        $sessao_model = \Sys\Sessao::objeto(self::$instance_token);

        // valida permissões
        \Sys\Permissions::verificar($sessao_model->dados->permissoes, 'areas');

        // instancio a área
        $area_dao = $this->LoadDAO('Area', true);

        $nome = (string)$this->ReadGet('nome');

        try {
            $lista = $area_dao->listar($nome);
            $this->print_json($lista);
        }
        catch (BusinessException $e) {
            $this->print_json($e);
        }

    }

}

Classe Util

static function DateNow($modify=null)

A função tem o objetivo retornar a data atual no formato MySQL ‘Y-m-d H:i:s’.

Parâmetro Descrição
$modify Aumenta ou diminui o número de dias a partir da data atual ex: +1 day
//Exemplo 1:
$data_atual = Util::DateNow();
print_r($data_atual);

//Exemplo 2:
$amanha = Util::DateNow('+1 day');
print_r($amanha);

static function Format_Date($date, $type=0)

Retona a data de entrada de acordo os seguintes formatos:

Constante Valor Significado
Util::FORMAT_DATE_DD_MM_AAAA 1 Formato em dias, mês e ano com quatro dígitos
Util::FORMAT_DATE_DD_MM_AA 2 Formato dia, mês e ano
Util::FORMAT_DATE_AAAA_MM_DD 3 Formato ano com quatro dígitos, mês, e dia
Util::FORMAT_DATE_AA_MM_DD 4 Formato ano, mês, dia

Atualmente é utilizado em importação de dados de planilhas Excel.

static function formatar_decimal($value)

Converte um valor decimal em uma string formatada, com separador de milhar e decimal

static function ObjectToArray($objeto)

Converte um objeto em array

static function ArrayToObject($array)

Converte um array em objeto

static function array_clone($array)

Clona um array, fazendo com que o novo objeto não tenha relação com o objeto origem.

static function recast($className, $object)

Converte um objeto genérico (stdClass) para um objeto de classe definida (ex: Cliente_Model).

Parâmetro Descrição
$className Nome da classe a ser convertido o objeto
$object Objeto a ser convertido

static function FilesArray($arquivos)

Converte a variável $_FILES em um array de objetos
Passar o nome do índice em $_FILES ao utilizar o FilesArray
Exemplo:

print_r($_FILES);

Array
(
    [documentos] => Array
    (
        [name] => Array
        (
            [0] => bp_oportunidades_obs.jpg
            [1] => visoes_gantt.png
            [2] => bp_rel_chamados.PNG
        )
        [type] => Array
        (
            [0] => image/jpeg
            [1] => image/png
            [2] => image/png
        )
        [tmp_name] => Array
        (
            [0] => C:\Windows\Temp\phpB4BD.tmp
            [1] => C:\Windows\Temp\phpB4CD.tmp
            [2] => C:\Windows\Temp\phpB4DE.tmp
        )
        [error] => Array
        (
            [0] => 0
            [1] => 0
            [2] => 0
        )
        [size] => Array
        (
            [0] => 20192
            [1] => 16732
            [2] => 31175
        )
    )
)

print_r(Util::FilesArray($_FILES['documentos']));

Array
(
    [0] => Array
    (
        [name] => bp_oportunidades_obs.jpg
        [type] => image/jpeg
        [tmp_name] => C:\Windows\Temp\phpB4BD.tmp
        [error] => 0
        [size] => 20192
    )
    [1] => Array
    (
        [name] => visoes_gantt.png
        [type] => image/png
        [tmp_name] => C:\Windows\Temp\phpB4CD.tmp
        [error] => 0
        [size] => 16732
    )
    [2] => Array
    (
        [name] => bp_rel_chamados.PNG
        [type] => image/png
        [tmp_name] => C:\Windows\Temp\phpB4DE.tmp
        [error] => 0
        [size] => 31175
    )
)

static fuction Colors($index=null)

Caso $index seja null, a função retorna um array com as cores do sistema, este array de cores possui de conteúdo um outro array com o nome da cor e o código da cor hexadecimal que pode ser utilizado em textos, caso a cor base seja utilizada como background.

Quando informado o $index a função pesquisa o mesmo e retorna o nome e cor de texto referente ao $index.

Obs: esta função é utilizada em relatórios, e-mails e qualquer outro processamento que possua cores predefinidas em registros do banco de dados. Também possui uma versão no frontend em javascript, normalmente esta função é utilizada em selects (frontend) de seleção de cores, exemplo: Motivo de Chamado, Status da Oportunidade, Tipo de Agenda…

static fuction valida_data($data)

Recebe uma string de data e verifica se o ano, mês e dia informados estão válidos.

Parâmetro Descrição
$data Data em texto no formato aaaa-mm-dd

static function diff_calcula_horas($inicio, $fim, $intervalo_inicial, $intervalo_final, $traslado=null)

Recebe hora inicial, hora final, intervalos de almoços e tempo de traslado, retorna o total de horas trabalhadas. Função utilizada exclusivamente em apontamento de projetos.

Exemplo:

echo Util::diff_calcula_horas('08:00', '18:00', '12:00', '14:00', '00:00');
// retorno 08:00

echo Util::diff_calcula_horas('08:00', '18:00', '12:00', '14:00', '03:00');
// retorno 11:00

static function string_to_array($param, $string, $verifica=true)

Converte uma string em um array, de acordo com separadores definidos, com opção de ignorar registros repetidos.

Obs: Semelhante a função explode(), porém com a possibilidade de definir mais que um separador e ignorar registros duplicadores

Parâmetro Descrição
$param Array de separadores, exemplo: array(‘;’, ‘,’)
$string String a ser convertida
$verifica Se true remove valores repetidos do array

static function dia_semana($dia)

Recebe uma data em string e retorna o nome do dia da semana de acordo com o idioma da sessão do usuário logado.

static function gera_token()

Gera e retorna uma chave MD5 sorteada.
Obs: chaves MD5 possuem 32 caracteres.

for ($i=0; $i < 10; $i++) {
    echo Util::gera_token() . PHP_EOL;
}

/* retorno
61294579a235b6f7ca24ef84a9183907
d8d1f39c711bc7fc342dbb11b5a063df
201fbbb73c6d836aceed1fbb2269831b
b2d3a904aabbbb67b7d74eeeb626d502
883be054f4e642074057a0f1380649f8
274b89649c9725a71c7ac3d801f24311
5a25e422e603a35a48f3b4b2e9f10289
250b92c5594d017d99ec9badeacb4dde
effe1b9f4131a133755506575e892261
988178b011d7c9199afa3184ea5b5802
*/

static function DiferencaDatasDias($inicio, $fim)

Recebe uma string de data de inicio e data final, retorna texto com a diferença de dias, exemplo:

print_r(Util::DiferencaDatasDias('2016-01-01', '2016-01-10'));

/* retorno:

Array
(
    [day_text] => 9 dias atrás
    [span] => danger
)
*/

print_r(Util::DiferencaDatasDias('2016-01-01', '2016-02-01'));

/* retorno:
Array
(
    [day_text] => 31 dias atrás
    [span] => danger
)
*/

print_r(Util::DiferencaDatasDias('2016-02-01', '2016-01-10'));

/* retorno:
Array
(
    [day_text] => faltam 22 dias
    [span] => default
)
*/

static function gera_grafico($valores, $cor=null, $nome, $width=null, $height=null, $legendas=null, $title=null)

Função para gerar uma imagem contendo um gráfico de pizza.

Descrição Parâmetro
$valores Array com os valores para montar o gráfico
$cor Array de cores que será utilizado no gráfico
$nome Nome físico da imagem que será gerada
$width Largura do gráfico que vai ser gerado
$height Altura do gráfico que vai ser gerado
$legendas Array de nomes para ser utilizado como legenda
$title Título que irá aparecer acima do gráfico

static function gerar_grafico_barras($valores, $grupos, $nome, $cor=null, $title=null, $width = null, $height = null, $format=null)

Função para gerar uma imagem contendo um gráfico de barras.

Parâmetro Descrição
$valores Array com os valores para montar o gráfico
$grupos Array com os nomes dos grupos
$cor Array de cores que será utilizado no gráfico
$nome Nome físico da imagem que será gerada
$width Largura do gráfico que vai ser gerado
$height Altura do gráfico que vai ser gerado
$format Nome da função que será usada com call-back.
$title Título que irá aparecer acima do gráfico

function gerar_grafico_media($cor, $motivos, $medias, $media_geral, $nome_arquivo, $title)

Função para gerar gráfico de linhas especifico para o relatório de chamado.

Parâmetro Descrição
$cor Array de cores que serão utilizadas
$motivos Array com os nomes dos motivos
$medias Array com os valores em segundos
$media_geral Array com os valores calculados em segundos
$nome_arquivo Nome do arquivo gerado
$title Título que irá aparecer acima do gráfico

static function ChamadoDescSituacaoHumano($situacao, $usuario_tipo=null)

Função usada para retornar uma String com o significado da situação do chamado. Recebe o número referente a situação do chamado e o tipo de usuário do sistema.

Exemplo:

Util::ChamadoDescSituacaoHumano(99);
//retorno Em aberto

static function define_status($hoje=null, $inicio=null, $prazo=null, $conclusao=null)

Função usada para retornar o status da atividade do projeto. Recebe todos os valores referente a datas da atividade e retorna o status.

Exemplo:

Util::define_status('2016-04-23', '2016-04-20', '2016-04-25'); //retorno ANDAMENTO
Util::define_status('2016-04-23', '2016-04-20', '2016-04-15');//retorno ATRASADO

static function MailFontFace()

Retorna a fonte padrão do sistema.

static function SendMail($from_name, $to, $subject, $body_subject, $body, $documentos=null, $token=null)

Função para enviar e-mail.

Parâmetro Descrição
$from_name Nome de quem enviou o e-mail se passar NULL o sistema tentar assumir o valor da constante APP_NOME
$to Endereço de e-mail para quem vai ser enviado
$subject Assunto do e-mail
$body_subject Assunto do e-mail detalhado, que fica ao lado do logo no corpo do e-mail
$body Corpo do e-mail que vai ser gerado
$documentos Array de documentos que serão anexados no e-mail

static function remove_acentos($str)

Remove os acentos da String que foi recebida de parâmetro.

static function IPAddr()

Retorna o IP de Client que está fazendo a requisição.

static function mime_type($filename)

Recebe o nome de um arquivo e retorna o tipo do arquivo (ex: jpg, png, xls).

static function addFolderToZip($dir, $zipArchive, $zipdir = ”)

Função para zippar pastas.

Parâmetro Descrição
$dir Nome do diretório que vai ser zippado
$zipArchive Objeto ZipArchive do php
$zipdir Destino do arquivo .zip gerado

static function Html2Text($html, $quebra_linha = false)

Função para remover as tags htmls de uma String, utilizada geralmente quando o texto vem do tinyMCE e vai ser salvo no banco de dados.

static function subtrair_horas($time1, $time2)

Função para subtrair horas recebe de parâmetros dois horários e retorna a diferença entre eles.
Obs: os horários podem conter 3 dígitos de hora.

static function sum_the_time($time1, $time2)

Função para subtrair horas recebe de parâmetros dois horários e retorna a soma entre eles.
Obs: os horários podem conter 3 dígitos de hora.

static function valor_campo_formulario($formulario, $campo_id, $novo_valor=null)

Função para obter e alterar valores de campos de formulário.

static function valor_campo_tabela_formulario(&$formulario, $campo_id, $linha, $novo_valor=null)

Função para obter e alterar valores de campos de tabelas de formulário.