Trivial

Nó de gravata

Carlos Lorenzon — Sat, 14 Apr 2012 19:51:20 +0000

Quem nunca teve problemas em dar um nó na gravata! Eu particularmente gosto do nó italiano (assim que conheço não sei se é o nome correto)

Para quem não consegue dar nó em gravata (bem vindo ao clube) segue um vídeo que deixara este processo mais simples.

abs

Instalando de forma simples e rapida o Subversion no CentOS 6

Carlos Lorenzon — Fri, 30 Mar 2012 02:41:34 +0000

Olá pessoal neste post irei mostrar de forma simples porém eficaz de como colocar seu servidor SVN no ar com autenticação e tudo mais.

Primeiramente certifique-se de ter instalado o subversion e o mod_dav
yum install mod_dav_svn subversion

Neste post estou supondo que você já tenha o apache instalado, então vamos configura-lo.
nano /etc/httpd/conf/httpd.conf

E insira isso
DAV svn SVNPath /var/www/svn/repos AuthType Basic AuthName "Subversion repos" AuthUserFile /etc/svn-auth-conf Require valid-user
E descomente estas linhas caso estejam comentadas
LoadModule dav_svn_module modules/mod_dav_svn.so LoadModule authz_svn_module modules/mod_authz_svn.so

Agora vamos criar os usuários, porém preste atenção que o primeiro usuário deve ser criado com um comando e os demais com o outro. O motivo disso é por que o primeiro comando cria o arquivo de senhas, isso poderia ser por banco de dados e tudo mais porém não entraremos nestes detalhes.

1º usuário
htpasswd -cm /etc/svn-auth-conf seu_usuario
Irá pedir os seguintes dados:
New password:
Re-type new password:

Para criar os próximos usuários utilize:
htpasswd -m /etc/svn-auth-conf seu_usuario2

Não esqueça de reiniciar o apache!

Com isso seu svn estará rodando no endereço: http://seu_ip/svn ou http://seu_dominio/svn caso tenha domínio configurado.

Espero ter ajudado! A não esqueça de criar os diretorios do repositório branches, tags, e trunk.

abs

Utilizando Classe Properties para I18N

fabianoc — Thu, 29 Mar 2012 03:28:12 +0000

Para internacionalizar um sistema de forma pratica deve se criar um arquivo com todas as strings que serão apresentadas no sistema, como por exemplo: botões, labels e Títulos.

Assim indico criar um arquivo com a extensão properties, se for pelo netbeans voce pode criar pelo menu criar novo arquivo e escolha o tipo “properties”. No netbeans tambem facilitará para adicionar as chaves e valores basta clicar com o botão direito sobre o arquivo após ele ser criado e ir no menu “adicionar / propriedade”. Porem não é dificil adicionar os valores na mão mesmo, basta adicionar a chave = valor , como mostro abaixo:

botao=Salvar
titulo.da.tela=programa de gerenciamento

Quando voce precisar do valor da chave “titulo.da.tela”, basta usar a Classe Properties do java, abaixo segue um exemplo da classe utilizando properties:

import br.com.printevo.enums.Idioma;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author fabianoc
 */
public class HandleProperties {  

    private Properties props;

    /**
     * Construtor
     *
     * @param String arquivo
     * nome do arquivo
     */
    public HandleProperties(String arquivo) {
        InputStream in = getClass().getClassLoader()
            .getResourceAsStream("resource/"arquivo".properties");
        try {
            loadProperties(in);
               // metodo exposto mais abaixo que executa o load
               // no conteudo do arquivo carregado no inputstream
        } catch (IOException e) {
            e.printStackTrace();
        }
    }  

    private void loadProperties(InputStream in) throws IOException {
        props = new Properties();
        props.load(in);
        in.close();
    }  

    /**
     *
     * @param chave chave para consulta.
     *
     * @return Valor da correspondente chave
     */
    public String getContent(String chave) {
        return props.getProperty(chave).trim();
             //metodo que retorna o valor (a propriedade) da chave que for informada
    } 

    //classe main para testar a classe
    public static void main(String[] args) {
        HandleProperties hp = new HandleProperties("lingua");
               //instanciando o objeto passando o parametro nome do arquivo
        String nome = hp.getContent("titulo.da.tela");
               // passa para string o valor de retorno do metodo
        System.out.println(nome); //imprime no console
    }
}

Daria tambem para montar um enum com os idiomas, para voce ao invés de passar string poderia passar um valor que nao precisaria ser validado.

Abraço a todos.

Manipular Variaveis de Ambiente Linux

fabianoc — Tue, 27 Mar 2012 02:11:04 +0000

Neste post ensinarei como manipular variáveis com definições de localização de pastas do linux, como por exemplo PATH, JAVA_HOME e ANT_HOME.

Para verificar o conteúdo de uma variável utilize o comando “echo” seguido do cifrão e o nome da variável:
shell# echo $PATH resultado será as pastas contidas nesta variável, algo como: /bin:/usr/bin:/usr/share/java
Note que os os valores são dividos com dois pontos “:”.

Para inserir valores em uma variável, utilizamos o comando “export” seguido do nome da variavel, sinal de igual e o valor a ser inserido.
shell# export PATH=$PATH:/usr/share/pasta resultado será a inclusão da pasta /usr/share/pasta no PATH
Note que acrescentei o $PATH depois do sinal de igual indicando que o valor do PATH será o valor que já existia e incluindo a pasta desejada.

Para apagar os valores de uma variável utilizamos o comando “unset” seguido do nome da variável:
shell# unset JAVA_HOME como resultado teremos o valor da variável JAVA_HOME apagado.

Como voce já de ve ter percebido que quando vamos atribuir valor ou apagar valor devemos utilizar somente o nome da variavel, e quando utilizamos o comando “echo” daí sim utilizamos o cifrão antes do nome da variável.

Espero ter ajudado.

Copiar uma tabela para outro Schema – Mysql

fabianoc — Wed, 11 Jan 2012 18:28:19 +0000

Ola a todos.

Abaixo segue um modo simples de copiar um tabela de um Schema para outro Schema em Mysql:

CREATE TABLE SchemaDestino.tabelaDestino SELECT * FROM SchemaOrigem.tabelaOrigem;

Duvidas ?? Utilize o campo abaixo.

Abraços.

Alterando layout do Netbeans (Look and Feel)

fabianoc — Tue, 10 Jan 2012 12:52:05 +0000

Para alterar o layout (visual) definindo um look and feel para o netbeans, siga os passos abaixo:

Estarei definindo o LAF (LookAndFeel) para Nimbus, que me pareceu o mais agradavel.

Abra a pasta onde esta instalado o Netbeans, no meu caso home/fabiano/netbans-7.1/etc/. Dentro da pasta abra em um editor o arquivo netbeans.conf, encontre a linha com: netbeans_default_options e acrescente ao final desta linha: --laf Nimbus, reinicie o NetBeans e já estará com o novo visual.

Precisei alterar este layout quando instalei o Linux Xfce e o Mate e o netbeans ficou com as letras bem pequenas e os menus aparecendo os separadores com a impressão que eu estava em modo de segurança.

Existem outros layouts disponiveis, porem o procedimento é igual mudando apenas o nome do Look and Feel.

Abraços.

Duvidas ?? Utilize o espaço abaixo.

Corrigir Cups Linux para mostrar Usuario

fabianoc — Mon, 09 Jan 2012 19:45:35 +0000

Olá a todos.

Abaixo segue como corrigir no Cups o nome dos usuários e nome dos documentos:

Entre através do browser em http://localhost:631/

Vá na aba “Administration”

Nesta aba existe um botão “Edit configuration file”, clique nele

Ache esta duas linhas :

JobPrivateAccess default
JobPrivateValues default

e deixe elas assim como esta abaixo

JobPrivateAccess all
JobPrivateValues none

Pronto encerre a sessão de seu usuário e entre novamente no linux

Agora só testar.

Duvidas?? Utilize o espaço abaixo.

Abraços.

Facilitando a vida criando classes “Utils”

Carlos Lorenzon — Sat, 05 Nov 2011 16:11:06 +0000

Olá pessoal, hoje vou escrever sobre como evitar ficar criando ifs e try catch a doidado nos seus codigos.

Eu em meus projetos utilizo muito o banco de dados MySQL e em diversas ocasiões necessito receber de interfaces gráficas números que indicam qual registro da tabela relacionada vai ser usada naquela cadastro.

Um exemplo setar qual cidade o cliente pertence.

E pegar esta informação que é um int através de um jTextField as vezes causa uma dor de cabeça por culpa dos NumberFormatException e NullPointerException e ~~temos de encher o código de try e catch~~ ou criar uma classe que faça este trabalho por nós.

Optei pela segunda opção.

Veja o código abaixo;

package br.com.nextd.erp.utils;
import javax.swing.JTextField;

/**
 * Classe de utilidades para tratar JTextFields
 * @author carlos
 */
public class TextFields {

    /**
        * Recebe o texto de uma JTextField e verifica se é apenas valores int ou se não esta vazio, caso esteja vazio ou com letras seta o valor 0
        * EX: TextFields.apenasInteger(cidadePessoa)
        * @param textField Passar para o metodo uma JTextField
        * @author carlos
        */
    public static int apenasInteger(JTextField textField){

        int numero = 0;
        try {
          numero = Integer.parseInt(textField.getText());
        } catch (NumberFormatException e){

        }  catch (NullPointerException e){

        }
        return numero;

    }

}

PHP sem POG a moda agora é OO

Carlos Lorenzon — Fri, 21 Oct 2011 04:24:30 +0000

Olá pessoal, recentemente comecei a estudar JAVA e vou dizer que este curso esta me ajudando muito!! Tanto em relação ao próprio JAVA quanto ao PHP.

Digo isso por quê estou mudando a visão estrutural que tinha para OO, e recentemente tem tomado mais cuidado na hora de escrever as classes, tomando principalmente cuidado com os padrões.

Alguns padrões que sigo:
Variáveis em minúsculas, caso sejam compostas a primeira letra da composição em maiúsculo.
Constantes em maiúsculas e caso seja composta separadas por underline “_”
As classes com nomes sugestivos e com a primeira letra em maiúscula e no singular (Ex: Cliente ).

Entre outros cuidados.

Mas vamos ao exemplo de uma classe MySQL (esta ainda tenho de revisar), uma chamada Cliente, um arquivo aonde fica as constantes do banco de dados (senha, usuario, banco e host) e o arquivo index.php que irá executar.

Bom a classe MySQL ficou desta forma.

```
 
```
```
class MySQL {
```
```
    var $dbi;
```
```
    var $query;
```
```
 
```

    // função que starta o MySql, sem ela é impossivel conectar ao banco

```
    function open()
```
```
    {
```

        // conecta com o bd com as variáveis prédefinidas

        $this->dbi = mysql_connect(DB_HOST, DB_USERNAME, DB_PASSWORD);

```
        if (!$this->dbi) {
```
```
            echo "Erro na conexão!";
```
```
        }
```

        if (!mysql_select_db(DB_DATABASE)) {

            echo "Erro na seleção do banco de dados!";

```
        }
```
```
    }
```
```
 
```
```
    // faz a query
```
```
    function query($query)
```
```
    {
```
```
 
```
```
    $queryBD = mysql_query($query);
```

    $dados = mysql_fetch_array($queryBD);

```
 
```
```
    return $dados;
```
```
 
```
```
    }
```
```
 
```

    // fecha a conexão com o bco de dados

```
    function close()
```
```
    {
```
```
        mysql_close($this->dbi);
```
```
    }
```
```
 
```
```
}
```
```
?>
```

Com isto já temos o suficiente para conectar ao banco, agora vamos ver a classe Cliente

```
/* 
```
```
 * 
```

 * Classe responsavel por cadastrar, editar, consultar e deletar clientes

```
 *
```
```
 */
```
```
 
```
```
 
```
```
class Cliente {
```
```
    private $id;
```
```
    private $nome;
```
```
    private $email;
```
```
    private $senha;
```
```
    private $cpf;
```
```
 
```
```
 
```

    function  __construct($id=0, $nome="", $email="", $senha="", $cpf=0) {

```
        $this->id = $id;
```
```
        $this->nome = $nome;
```
```
        $this->email = $email;
```
```
        $this->senha = $senha;
```
```
        $this->cpf = $cpf;
```
```
    }
```
```
 
```
```
 
```
```
    public function getId(){
```
```
        return $this->id;
```
```
    }
```
```
 
```
```
    public function getNome(){
```
```
        return $this->nome;
```
```
    }
```
```
 
```
```
    public function getEmail(){
```
```
        return $this->email;
```
```
    }
```
```
 
```
```
    public function getSenha(){
```
```
        return $this->senha;
```
```
    }
```
```
 
```
```
    public function getCpf(){
```
```
        return $this->cpf;
```
```
    }
```
```
 
```
```
    public function getById($id){
```
```
        $db = new MySQL();
```
```
        $db->open();
```
```
 
```

        $cliente = $db->query("SELECT * FROM cliente WHERE id = $id and 1 = 1");

```
 
```
```
        $db->close();
```
```
 
```

        return new Cliente($cliente['id'], $cliente['nome'], $cliente['email'], $cliente['senha'], $cliente['cpf']);

```
 
```
```
    }
```
```
 
```
```
    public function getByNome($nome){
```
```
        $db = new MySQL();
```
```
        $db->open();
```
```
 
```
```
        $busca = strtoupper($nome);
```

        $cliente = $db->query("SELECT * FROM cliente WHERE UPPER(nome) = '$busca' and 1 = 1");

```
 
```
```
        $db->close();
```
```
 
```

        return new Cliente($cliente['id'], $cliente['nome'], $cliente['email'], $cliente['senha'], $cliente['cpf']);

```
 
```
```
    }
```
```
}
```
```
?>
```

Agora vamos juntar as duas classes, vamos supor que no banco de dados na tabela cliente tivesse os seguintes dados com o id “1″.

Nome: Carlos Lorenzon
Email: carlos[]nextd.com.br

Usando a classe cliente pegaríamos desta forma os dados

include 'conf.php'; // Aonde esta as constantes do banco e outras definições

include 'class/MySQL.php'; // Acesso ao banco de dados

include 'class/Cliente.php'; // Classe responsavel por administrar as informações dos clientes

```
 
```
```
$cliente = new Cliente();
```
```
 
```
```
$cliente = $cliente->getById(1);
```
```
 
```
```
echo $cliente->getEmail();
```
```
echo "
"
```
```
echo $cliente->getNome();
```
```
 
```
```
?>
```

O que imprimiria a seguinte informação

carlos[]nextd.com.br
Carlos Lorenzon

Bom espero que tenham gostado destas classes e desta forma de utilizar o PHP, abandonando o paradigma de linguagem estrutural e enriquecendo seu sistema (e quem sabe seu bolso também).

T+ pessoal

Restaurar backup mysql

fabianoc — Mon, 17 Oct 2011 16:15:53 +0000

Uma forma simples para restaurar um backup via prompt ou shell.

Digite o comando abaixo:

mysql -u usuario -h suaconexao -psuasenha < /home/cardosao/backup/backupdobanco.sql

Abraços