RSS
 

Desenvolvendo plugins para WordPress

19 ago

O que é um plugin WordPress?

Um plugin WordPress são classes e/ou funções criadas para incrementar ao WordPress novas funcionalidades ou estendê-las.

Porque criar plugins para WordPress?

Criar plugins para WordPress parte da necessidade de atribuir a ele alguma outra nova funcionalidade que não tem por padrão. Funcionalidades que por vez podem ser usadas para projetos pessoais ou para ajudar toda a comunidade que usam o WordPress.

Por onde começar?

Atualmente, o WordPress possui mais de 10.000 plugins desenvolvidos, e é sempre recomendado que verifique antes se já existe um plugin que faça o pretendido. Assim não haverá a necessidade do desenvolvimento.

É recomendado também ter curiosidade em ver como outros plugins renomados funcionam e analisar seu funcionamento para um bom entendimento e fazer um desenvolvimento mais profissional.

Procure ao máximo usar as funções nativas do WordPress, não reinvente a roda. Estude e conheça cada dia mais o WordPress.

Quais os pré-requesitos para começar a desenvolver um plugin WordPress?

O WordPress é feito com PHP, então nada mais justo do que um bom conhecimento nessa linguagem, ela é o começo de tudo.

O grande salto para o desenvolvimento de plugins WordPress é, através de seu conhecimento PHP,  navegar pelos códigos do WordPress e entender como é o seu funcionamento, como ele lida funções ou métodos de suas classes. Isso ajuda muito na hora do desenvolvimento.

Ter sempre ao seu alcance ao Codex do WordPress é fundamental para consultas e obter um bom entendimento de tudo que o WordPress pode nos auxiliar.

Links úteis

WordPress Codex

Codex Plugins

Plugin Directory

Configure sua máquina virtual como PHP, Apache, MySQL e comece agora mesmo a desenvolver aquela necessidade que você tem e que o WordPress não lhe proporciona nativamente.

 
1 Comment

Posted in WordPress

 

Como criar um projeto usando a Zend_Tool do Zend Framework

17 mai

Para darmos inicio a criação do projeto usando a Zend_Tool, faça o download do Zend Framework caso não o tenha. Após o download, abra a central de comando do seu sistemas operacional e acesse o arquivo zf.bat(windows) ou zf.sh(linux e mac) localizados na pasta bin do Zend Framework.

Feito isso, uma instância da classe Zend_Tool é criada e você já pode efetuar os comandos ele vos fornece, primeiramente com um pequeno “help” na janela de comando.

Para criar um projeto a partir daqui é muito simples. Digite a linha de comando abaixo informando o caminho do projeto e seu nome. Seu projeto será criado neste momento.

zf create project path name-of-profile file-of-profile

Pronto, seu projeto está criado e pronto para ser usado, testado e configurado da forma como você e seu projeto necessita. Usa a imaginação, a estrutura básica a Zend_Tool já criou pra você.

 
 

O que há de novo no Zend Framework 1.10.4

30 abr

Já está disponível a versão 1.10.4 do Zend Framework, a quarta versão da série 1.10.  A versão contribui para estabilizar e melhorar a série 1.10. Nela foram corrigidos mais de 50 bugs, confira o changelog da versão e atualize-se com a novidades.

 

O que há de novo no Zend Framework 1.10.3

05 abr

Essa semana foi lançado o Zend Framework 1.10.3 com a correção de cerca de 80 bugs de segurança corrigidos. Você já pode baixar a nova versão do Zend Framework e também pode conferir o changelog desta nova versão.

A comunidade do Zend Framework cresce cada dia mais, é muito bom fazer parte e contribuir para seu crescimento.

 

Como fazer upload de imagens usando Zend Framework

25 mar

Olá developers,

hoje vamos aprender como fazer upload de imagens usando Zend Framework. Vale lembrar que o exemplo que vou citar aqui segue a estrutura e configuração do nosso Sample Project.

Criando o Formulário

Primeiramente criaremos nosso formulário chamado UploadImage.php contendo um campo do tipo file e um botão para submeter. Esse formulário será criado no diretório library/Sample/Form/ que é onde armazeno todos os formulários da aplicação. O local onde será criado o formulário fica a critério de cada um.

Segue o código do formulário:

class Sample_Form_UploadImage extends Zend_Form
{
    public function init()
    {
        // Seta a action do formulário
        $this->setAction('');

        // Seta o método de envio do formulário como POST
        $this->setMethod( Zend_Form::METHOD_POST );

        // Seta o enctype do formulário para upload de arquvos
        $this->setEnctype( Zend_form::ENCTYPE_MULTIPART );

        // Inicia aqui a criação e configuração do campo file_image
        $file_image   = new Zend_Form_Element_File('file_image');
        $file_image ->setLabel('Selecione a imagem')
                    ->setRequired(true)
                    ->addValidator( new Zend_Validate_File_Extension('jpeg','jpg','gif','png') );

        // Inicia aqui a criação e configuração do botão de submit
        $submit = new Zend_Form_Element_Submit('submit');
        $submit->setLabel('Fazer upload');

        // Adiciona os elementos ao formulário
        $this->addElements(array(
            $file_image,
            $submit
        ));
    }
}

Note que aplicamos um validador para as extensões do arquivo, validando apenas extensões de imagens, JPEG, JPG, GIF e PNG.

Configurando o Controller

Em algum controller de sua aplicação, instancie o formulário de upload de imagens e defina alguns métodos que serão chamados para que o upload ocorra perfeitamente. Eu utilizei o indexController para o exemplo, veja  abaixo:

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialize action controller here */
    }

    public function indexAction()
    {
        // Instancia o formulário
        $objFormImageUpload = new Sample_Form_UploadImage();

        // Envia para a view
        $this->view->objFormUploadImage = $objFormImageUpload;

        // Verifica se foi uma requisição POST
        if( !$this->_request->isPost() )
            return false;

        // Capturamos aqui o dados enviados via post
        $data = $this->_request->getPost();

        // Verifica se os dados do formulário são válidos
        if( !$objFormImageUpload->isValid($data) )
            return false;

        // Instancia o adaptador do Zend para tranferência de arquivos via
        // protocolo Http e definine o destino do arquivo
        $upload_adapter = new Zend_File_Transfer_Adapter_Http();
        $upload_adapter->setDestination( UPLOAD_PATH );

        if( $upload_adapter->receive() )
            echo 'Upload efetuado com sucesso';
        else
            echo 'Ops! Ocorreu um erro ao enviar o arquivo';
    }
}

Exibindo na View

Na view respectiva ao seu controller, exiba o formulário.

echo $this->objFormUploadImage;

Conclusão

Bom, esse é um exemplo simples de como fazer upload de imagens usando o Zend Framework, para se aprofundar mais no assunto, visualize a documentação.

Nota: Para fazer o upload de arquivos em geral, de qualquer extensão, apenas retire a validação de extensões. Simples não?

Comentem suas dúvidas, críticas e sugestões.

Até a próxima.

 

Como criar um plugin para WordPress

19 fev

Developers,

navegando no blog no meu parceiro @leandroviera, me deparei com os slides de sua palestra no CMS Brasil de 2009, e como são muito boas as suas explicações, segue abaixo para vocês consultarem e aprenderem mais um pouco sobre como criar um plugin para wordpress.

Abraços

 
2 Comments

Posted in WordPress

 

O que há de novo no Zend Framework 1.10.1

11 fev

Saiu ontem a versão Zend Framework 1.10.1, a primeira da série 1.10 lançada no último mês. Foram corrigidos mais de 50 bugs desde a versão 1.10.0, trazendo mais estabilidade e maturidade ao Zend Framework.
No nosso manual online também obtivemos novidades, como a integração dos usuários através de comentários, bastando inserir nome, senha e CAPTCHA, todos comentários serão moderados com verificação de spam e moderação pela equipe da Zend. Este mesmos comentários, só poderão ser feitos na atual versão do framework, assim evitando diferentes informações de uma versão para a outra.

É isso developers, espero que o Zend Framework continue crescendo assim e melhorando cada vez a nossa vida como desenvolvedor!

Abraços

 

Como criar um sistema de login com Zend Framework

06 fev

Developers,

primeiramente entendam que Zend_Auth lida apenas com autenticação e não autorização (mais para frente iremos ver como através da Zend_Acl). A autenticação é feita com base em credenciais, verificando a identidade do usuário, portanto vamos criar uma tabela de usuários chamada users em nosso banco de dados Sample Project.

Criando a tabela no banco de dados

CREATE TABLE `sampleproject`.`users` (
`user_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`user_name` VARCHAR( 150 ) NOT NULL ,
`user_email` VARCHAR( 64 ) NOT NULL ,
`user_password` CHAR( 40 ) NOT NULL
) ENGINE = MYISAM COMMENT = 'Tabela de usuários';

Criando conexão com o banco de dados

Recentemente publiquei um artigo sobre como criar conexão com banco de dados MySQL usando Zend Framework. Nele a aplicação está bem completa.

Criando o formulário de login

class Sample_Form_Login extends Zend_Form
{
    public function init()
    {
        $this->setAction('');
        $this->setMethod('POST');

        $user_email = new Zend_Form_Element_Text('user_email');
        $user_email ->setLabel('Email');

        $user_password = new Zend_Form_Element_Password('user_password');
        $user_password->setLabel('Senha');

        $act = new Zend_Form_Element_Submit('act');
        $act->setLabel('Entrar');

        $this->addElements(
            array(
                $user_email,
                $user_password,
                $act
            )
        );
    }
}

Criando o AuthController

Nesse controlller é onde criaremos nossas regras de negócios de login e logout.

class AuthController extends Zend_Controller_Action
{

    public function init()
    {

    }

    public function indexAction()
    {
        // Redireciona para o login
        $this->_redirect('auth/login');
    }

    public function loginAction()
    {
        // Instancia o formulário de login
        $objFormLogin = new Sample_Form_Login();
        $this->view->objFormLogin = $objFormLogin;

        // Verifica se foi submetido via POST
        if( !$this->_request->isPost() )
            return false;

        // Obtém os dados passados via POST
        $data = $this->_request->getPost();

        // Se os dados forem validos
        if( !$objFormLogin->isValid($data))
            return false;

        // Cria uma instancia de Zend_Auth
        $objAuth = Zend_Auth::getInstance();

        /**
         * Instancia o Auth Db Table Adapter
         *
         * Quando se instancia este objeto, precisamos informar as configurações
         * do BD, nome da tabela onde os dados de login estão, o campo do nome
         * do usuário, e o campo da senha na tabela.
         */
        $authAdapter = new Zend_Auth_Adapter_DbTable(
                Zend_Registry::get( 'db' ),
                'users',
                'user_email',
                'user_password',
                'sha1(?)'
        );

        // Configura as credencias user_email e user_password informadas pelo usuário
        $authAdapter->setIdentity( $data['user_email'] )->setCredential( $data['user_password']);

        // Tenta autenticar o usuário
        $result = $objAuth->authenticate($authAdapter);

        /**
         * Se o usuário for autenticado redireciona para a index e grava seu email,
         * caso contrário exibe uma mensagem de alerta na página
         */
        if ( $result->isValid() ) :

            /**
             * Pega os dados do usuário, omitindo a senha
             * http://framework.zend.com/manual/en/zend.auth.adapter.dbtable.html
             */
            $authData = $authAdapter->getResultRowObject( null, 'user_password' );

            // Armazena os dados do usuário
            $objAuth->getStorage()->write( $authData );

            echo 'Login efetuado com sucesso!';
        else :
            echo 'Os dados informados (e-mail e/ou senha) não são válidos.';
        endif;
    }

    public function logoutAction()
    {
        $objAuth = Zend_Auth::getInstance();

        // Limpa a autenticação
        $objAuth->clearIdentity();
    }
}

Registrando o namespace “Sample”

Para que o zend entenda ao chamar a classe Sample_Form_Login(), é necessário que dentro do seu bootstrap você registre o namespace “Sample”, que é onde você vai guardar seus formulários, dentre eles o formulário de login.
Nesta função é criada um auto-carregamento dos conteúdos que ali estão, veja como ficará seu bootstrap.

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initAutoLoader()
    {
        // Cria uma instancia de autoloader
        $autoloader = Zend_Loader_Autoloader::getInstance();

        // Registra o namespace Sample
        $autoloader->registerNamespace('Sample');
    }
}

Concluindo

Bom pessoal, aprendemos como criar uma conexão com banco da dados MySQL, criamos um formulário de login usando Zend_Form e criamos nossa classe de autenticação AuthController com as actions de login e logout. Nossa muito conteúdo para apenas um post! :D Então pessoal, agora é vocês adaptarem esse sistema na aplicação de vocês!

Abraços e comentem suas dúvidas, críticas e/ou elogios!

 

Como usar a Zend_Tool para criar um projeto em Zend Framework

05 fev

Developers,

hoje é um vídeo bacana sobre como criar um projeto em Zend Framework usando a Zend_Tool. Após baixar o Zend Framework, siga os passos do vídeo abaixo.

E não deixem de postar suas dúvidas.

Abraços.

 

Como criar conexão com banco de dados MySQL usando Zend Framework

02 fev

Developers,

para criarmos uma conexão com um banco de dados é muito simples. No arquivo de configuração application.ini, definiremos nossos resources (recursos) para conexão.

resources.db.adapter = "pdo_mysql"
resources.db.params.host = "mysql.servidor.com"
resources.db.params.username = "seunomedeusuario"
resources.db.params.password = "suasenhadobancodedados"
resources.db.params.dbname = "nomedobancodedados"
resources.db.params.charset = "utf8"
resources.db.isDefaultTableAdapter = true

Com esses parâmetros definidos, precisaremos agora criar uma função protegida dentro do Bootstrap.php para criar a conexão. Vamos dar o nome de _initConnection.

    /**
     * Função faz a conexão com o banco de dados e registra a variável $db para
     * que ela esteja disponível em toda a aplicação.
     */
    protected function _initConnection()
    {
        /**
         * Obtém os resources(recursos).
         */
        $options    = $this->getOption('resources');
        $db_adapter = $options['db']['adapter'];
        $params     = $options['db']['params'];

        try{

            /**
             * Este método carrega dinamicamente a classe adptadora
             * usando Zend_Loader::loadClass().
             */
            $db = Zend_Db::factory($db_adapter, $params);

            /**
             * Este método retorna um objeto para a conexão representada por uma
             * respectiva extensão de banco de dados.
             */
            $db->getConnection();

            // Registra a $db para que se torne acessível em toda app
            $registry = Zend_Registry::getInstance();
            $registry->set('db', $db);

        }catch( Zend_Exception $e){

            echo "Estamos sem conexão ao banco de dados neste momento. Tente mais tarde por favor.";

            exit;
        }

    }

Se conseguirmos assimilar bem os comandos do Zend Framework, vemos que ele não é tão assim um bicho de sete cabeças! :D

É isso developers! Abraços!