domingo, 29 de maio de 2011

Mais um Erro Simples de resolver => failed to open stream: HTTP wrapper does not support writeable connections in

Hoje quando estava criando um formulário com upload de imagens tive o seguinte erro "failed to open stream: HTTP wrapper does not support writeable connections in" fiz uma pesquisa rápida no google e verifiquei que muitas pessoas passaram por este problema, então decidir compartilhar como resolvi este problema.

Esse erro é simples de resolver, observe em seu código você deve estar passando o caminho absoluto para o diretório onde a imagem irá ficar e é ai que esta o erro, você deve apenas informar o diretório onde a imagem irá ficar.

Exemplo:

Ao invés de usar
      $caminhoImg = "http://www.site.com.br/upload/img/";
Use
      $caminhoImg = "upload/img/";


Comigo isso resolveu.

quarta-feira, 11 de maio de 2011

unexpected T_CLASS - Erro chato mas simples

Hoje tive um problema chato, não aquele chato de difícil aquele chato de incomodar, sempre desenvolvo os sistemas em uma maquina local e como reutilizo frameworks ou classes prontas para facilitar no desenvolvimento o sistema funciona corretamente em localhost mas quando realizei o upload para o servidor apareceu este erro "unexpected T_CLASS" esse erro se deve ao formato Unix do arquivo, sendo assim a solução para este erro é salvar o arquivo em outro formato. Fica ai a dica para aqueles que encontram este problema. Mudem o formato Unix do arquivo.

quinta-feira, 21 de abril de 2011

Integrando Zend Framework -1.11.4 com Smarty -3.0.6

Olá, galera, hoje irei apresentar como usar o Smarty com o Zend Framework.


Smarty é uma biblioteca em Php que possibilita separar a interface gráfica da lógica de programação, desta forma o web design não irá interferir na lógica de programação e o programador não irá interferir no layout do site, isso gera uma grande facilidade em trabalhos em equipe  com isso facilita e melhora o desenvolvimento de qualquer aplicação em Php.


Zend Framework é um framework de código aberto totalmente orientado a objeto e seguindo rigorosamente o padrão MVC mantendo assim o código sempre limpo e de fácil manutenção por qualquer um que for dar suporte ao site.


O Zend já possui um ótimo sistema de views que trabalha com a extensão .phtm, então porque usar um outro sistema de templates. 


As views .phtml utilizam script php para apresentar as informações com isso o web design terá que ter conhecimentos em php ou o programador php terá que trabalhar com os layouts. Outra grande vantagem que encontro no uso do Smarty é que imagina que haverá uma mudança de framework agora irá utilizar o CakePhp, CodeIgniter  ou algum outro, se você utilizar Smarty não haverá a necessidade de mudar nenhum tipo de tratamento no layout. 


Não vou abordar sobre as vantagens e desvantagens de se utilizar o Smarty com Zend Framework, na internet existem muitos artigos abordando esse tema. Aqui vou apenas apresentar como é simples a integração entre os dois, então vamos ao que interessa.


Neste post utilizei o Zend Tool para criar o projeto, num post posterior ensino como instalar o Zend Tool e usar as suas funcionalidades.
Link para download do Zend http://www.framework.zend.com/download/current/
Link para download do Smarty http://www.smarty.net/download

Neste post eu considero que você já tenha criado o projeto seguindo os padrões da ZF, como o Zend Tool não adiciona a biblioteca automaticamente abra a pasta do ZF que você baixou e copie a pasta Zend ela se encontra dentro da pasta library, agora cole ela dentro da pasta library do seu projeto.
Agora vá para a pasta do Smarty que você baixou e copie a pasta libs e cole ela dentro da pasta library do seu projeto, agora mude o nome da pasta libs para Smarty.

Com isso você tem as duas bibliotecas já gravadas em seu projeto agora vamos realizar a integração entre as duas.

Abra o application.ini o caminho padrão dele é application\configs\application.ini e adicione a linha autoloadernamespaces[] = "SmartyMain";

Exemplo do application.ini







Dentro do arquivo Bootstrap.php adicione o método abaixo, ele que indica ao ZF qual tipo template usar e onde ele se encontra:


protected function _initView()  
    {  
  
        // aqui podemos passar quaisquer parâmetros que sejam atributos do objeto smarty  
        // se quisermos habilitar o cache, por exemplo:  
        $params = array(  
                      'caching'        => true,  
                      'cache_lifetime' => 30  
                  );  
                  
        
        /*
         * Aqui você define onde encontrar as pastas do templates, templates_c, cache e config
         */
        $view = new SmartyMain('application/views/', $params);  
        
        
        $viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer();  
       
        
        /*
         * Aqui define como o Zend irá encontrar o template necessário para cada ação do usuário não é indicado alterar
         * 
         */
        $viewRenderer->setView($view)  
                     ->setViewBasePathSpec($view->getEngine()->template_dir)  
                     ->setViewScriptPathSpec(':controller/:action.:suffix')  
                     ->setViewScriptPathNoControllerSpec(':action.:suffix')  
                     ->setViewSuffix('tpl');  
        Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);  
  
    } 


Agora você terá que criar a Classe SmartyMain.php dentro da pasta library, esta classe é responsável por instânciar a classe Smarty é e nesta classe que você define as pastas onde ficarão os templates.


<?php

require_once('Smarty/Smarty.class.php');

class SmartyMain implements Zend_View_Interface
{

    /**
     * Smarty object
     * @var Smarty
     */
    protected $_smarty;

    /**
     * Constructor
     *
     * @param string $tmplPath
     * @param array $extraParams
     * @return void
     */
    public function __construct($tmplPath = null, $extraParams = array())
    {
        $this->_smarty = new Smarty();

        if (null !== $tmplPath) {
            $this->setScriptPath($tmplPath);
        }

        foreach ($extraParams as $key => $value) {
            $this->_smarty->$key = $value;
        }
    }

    /**
     * Return the template engine object
     *
     * @return Smarty
     */
    public function getEngine()
    {
        return $this->_smarty;
    }

    /**
     * Set the path to the templates
     *
     * @param string $path The directory to set as the path.
     * @return void
     */
    public function setScriptPath($path)
    {


        if (is_readable($path)) {
            
            /*
             * Aqui você irá definir quais são os diretorios onde os templates, templates_c , cache e config serão armazenados
             * estes nomes são o padrão do Smarty
             */
            
            $this->_smarty->template_dir = $path."templates";
            $this->_smarty->compile_dir  = $path."templates_c";
            $this->_smarty->cache_dir    = $path."cache";
            $this->_smarty->config_dir   = $path."config";
            
            return;
        }

        throw new Exception('Invalid path provided');
    }

    /**
     * Retrieve the current template directory
     *
     * @return string
     */
    public function getScriptPaths()
    {
        return array($this->_smarty->template_dir);
    }

    /**
     * Alias for setScriptPath
     *
     * @param string $path
     * @param string $prefix Unused
     * @return void
     */
    public function setBasePath($path, $prefix = 'Zend_View')
    {
        return $this->setScriptPath($path);
    }

    /**
     * Alias for setScriptPath
     *
     * @param string $path
     * @param string $prefix Unused
     * @return void
     */
    public function addBasePath($path, $prefix = 'Zend_View')
    {
        return $this->setScriptPath($path);
    }

    /**
     * Assign a variable to the template
     *
     * @param string $key The variable name.
     * @param mixed $val The variable value.
     * @return void
     */
    public function __set($key, $val)
    {
        $this->_smarty->assign($key, $val);
    }

    /**
     * Allows testing with empty() and isset() to work
     *
     * @param string $key
     * @return boolean
     */
    public function __isset($key)
    {
        return (null !== $this->_smarty->get_template_vars($key));
    }

    /**
     * Allows unset() on object properties to work
     *
     * @param string $key
     * @return void
     */
    public function __unset($key)
    {
        $this->_smarty->clear_assign($key);
    }

    /**
     * Assign variables to the template
     *
     * Allows setting a specific key to the specified value, OR passing
     * an array of key => value pairs to set en masse.
     *
     * @see __set()
     * @param string|array $spec The assignment strategy to use (key or
     * array of key => value pairs)
     * @param mixed $value (Optional) If assigning a named variable,
     * use this as the value.
     * @return void
     */
    public function assign($spec, $value = null)
    {
        if (is_array($spec)) {
            $this->_smarty->assign($spec);
            return;
        }

        $this->_smarty->assign($spec, $value);
    }

    /**
     * Clear all assigned variables
     *
     * Clears all variables assigned to Zend_View either via
     * {@link assign()} or property overloading
     * ({@link __get()}/{@link __set()}).
     *
     * @return void
     */
    public function clearVars()
    {
        $this->_smarty->clear_all_assign();
    }

    /**
     * Processes a template and returns the output.
     *
     * @param string $name The template to process.
     * @return string The output.
     */
    public function render($name)
    {
        return $this->_smarty->fetch($name);
    }

}

Agora crie os diretórios onde ficarão os templates,  o padrão que esta sendo utilizado é esse:









Usando o padrão do ZF Controller/Action de acesso as views,  para cada controller você deverá criar uma pasta e dentro desta pasta o nome do template e ele é de acordo com a ação a ser realizada, exemplo:

Para o  IndexController ficara desta forma templates/index/index.tpl

Para o AlunoController ficara desta forma templates/aluno/index.tpl

Para o AlunoController ficara desta forma templates/aluno/novo.tpl

Dependendo da ação a ser executada irá chamar o template necessário.



Estrutura completa do projeto:






Que tal agora fazer um teste, adicione o método abaixo dentro da classe IndexController 




    public function indexAction()
    {
        // cria algumas variáveis  
        $projeto = "Integrando Smarty e Zend Framework";  
        $dados_completo = array(  
            array('nome' => 'Wesley', 'sobrenome' => 'David Santos'),
            array('nome' => 'Fulano', 'sobrenome' => 'de tal')  
        );  
        // inclui as variáveis na view  
        $this->view->assign('projeto', $projeto);  
        $this->view->assign('dados_completo', $dados_completo);  
    }



Agora dentro do index.tpl localizado dentro de templates/index/index.tpl adicione:

<p>{$projeto}</p>  
<table>  
    
    {foreach from=$dados_completo item=registro}  
    <tr>  
        <td>{$registro.nome}</td>  
        <td>{$registro.sobrenome}</td>  
    </tr>  
    {/foreach}  
</table>  


Agora é só abrir o navegador e testar.

Espero que tenham gostado, qualquer dúvida estou a disposição.

terça-feira, 19 de abril de 2011

COMO RESOLVER Strict Standards: Only variables should be passed by reference

Oi, galera.

Venho apresentar a vocês um erro que tem ocorrido muito nas novas versões do Php, " Strict Standards: Only variables should be passed by reference " (Erro fatal: Apenas as variáveis ​​podem ser passadas por referência), este erro informa que você só pode passar variáveis como referência e não uma função que retorna uma matriz.

Eu não conhecia este erro até que ele bateu na minha porta. Então vamos deixar de enrolar e falar como resolver este erro.

Verifique a linha que informa o erro provavelmente você está passando como referência um função que retorna uma matriz, exemplo:

     <?php 
   
         $nome = "wesley_david_santos";
         $nome_arr = end( explode( '_', $nome) );


   ?>

No exemplo acima a variável $nome recebe um texto separado por underline ( _ ), na linha seguinte a variável passa pela função explode() onde é transformado em um array que já é passado como referência para a função end() e é nisso que gera o erro, pois não é permitido passar o retorno de um array para outra função, o método que você deve fazer é atribuir este retorno a uma variável e usar esta variável como referência, exemplo:


    <?php 
      
         $nome = "wesley_david_santos";
         $arr = explode( '_', $nome) ;
         $nome_arr = end( $arr );

   ?>

Neste exemplo estou atribuindo o retorno da função explode() a uma variável com o nome de $arr e estou passando esta variável como referência na função end() desta forma não gera o erro.

Um outro exemplo meio grotesco de fazer isso, não recomendo, estou mostrando para que você possa ver outra forma de contornar o erro.

     <?php 
      
         $nome = "wesley_david_santos";
         $nome_arr = end( $arr = explode( '_', $nome) );

   ?>
Neste exemplo já atribuo o array a uma variável que já é passada como referência para a outra função.

Esse erro é gerado por uma corrupção na memória, uma vez cheguei a ler rapidamente isso na documentação do Php. 

Mesmo se ainda não aconteceu contigo, evite passar o retorno de uma matriz como referência para outra função pois talvez a versão do seu Php ainda não identifica este erro mas um dia você vai atualizar a versão, e ai complicou, abrir os scripts e alterar, então é melhor evitar.

Qualquer dúvida estou as ordens.     

COMO RESOLVER Erro Strict Standards: Declaration of

Oi galera.


Esses dias tive um erro chato para resolver quando tive que mudar todo um projeto feito em Php para outro servidor, quando terminei de transferir todos os arquivos para novo servidor lá estava ele :  Strict Standards: Declaration of na verdade este não é um erro e sim um warning (aviso), o Php sugere mudanças ao seu código as quais irão assegurar melhor interoperabilidade e compatibilidade futura do seu código.


Fiz algumas pesquisas na internet e descobrir que é por sobrecarga de método, pois como muitos sabem o Php não aceita sobrecarga de métodos em comparação a Java, C# entre outros. 


Para resolver este problema é o seguinte :
Referêncie a classe de pai de forma correta para que o Php possa identificar que se trata de classes diferentes, use o parent::nomeMetodo() para chamar métodos da classe pai e se mesmo assim o erro continuar é porque o _autoload ou outra forma de include que você utiliza pode ter chamado a subclasse antes da classe pai ser analisado.


Uma outra forma não recomendada de para de exibir estes erros é usar o código:
error_reporting(0);
ini_set(“display_errors”, 0 );

com isso o Php não irá exibir nenhum tipo de erro na tela, mas isso não é recomendado pois pode causar falhas de segurança, ou mal funcionamento do seu site.


Quando você estiver desenvolvendo um projeto sempre adicione o código:
error_reporting(E_ALL);
ini_set(“display_errors”, 1 );

e o Php irá exibir todos os erros na tela.

É isso qualquer dúvida é só entrar em contato.