Usage
The behavior usage is pretty simple. First, add the behavior to the ActiveRecord where you intend to
use it:

<?php
class User extends ActiveRecord {
	...
	public function behaviors() {
		return array(
			'AttributesBackupBehavior' => 'ext.AttributesBackupBehavior',
		);
	}
	...
}
?>

After this, 3 new methods will be added to your User class: attributesChanged(), attributeChanged()
and getOldAttributeValue().

Below is a description of it:

attributesChanged()
With this method you can check if any of the object attributes was changed after it was loaded from
the database:

<?php
$user = User::model()->find(); // User->status == 'Active'
var_dump($user->attributesChanged()); // FALSE
$user->status = 'Inactive';
var_dump($user->attributesChanged()); // TRUE
?>

attributeChanged()
This should be used when you want to know if a specific attribute value was changed:

<?php
$user = User::model()->find(); // User->status == 'Active'
$user->status = 'Inactive';
var_dump($user->attributeChanged('email')); // FALSE
var_dump($user->attributeChanged('status')); // TRUE
?>

getOldAttributeValue()
In case you need to retrieve the original value loaded from the database, this is the method you gonna use:

<?php
$user = User::model()->find(); // User->status == 'Active'
$user->status = 'Inactive';
var_dump($user->getOldAttributeValue('status')); // 'Active'
?>

Besides those three methods, there’s also one property that can be configured in this behavior:
$reloadAfterSave.

By default, after you call the ActiveRecord save method, the old attributes will be erased and filled
with the just saved new ones, show it will reflect the stored record. If for some reason you want
to keep the original loaded values, you need to set $reloadAfterSave as false:

<?php
class User extends ActiveRecord {
	...
	public function behaviors() {
		return array(
			'AttributesBackupBehavior' => array(
				'class' => 'ext.AttributesBackupBehavior',
				'reloadAfterSave' => false,
		);
	}
	...
}
?>

You can donwload the extension from its page at the Yii Framework site: http://www.yiiframework.com/extension/attributesbackupbehavior/

You can also fork the projet at Github: https://github.com/davialexandre/AttributesBackupBehavior

A maneira mais fácil de fazer isso é adicionar uma coluna na tabela de posts, que será utilizada para armazenar o número de visitas para aquele item. Cada vez que um post for exibido o valor dessa coluna será aumentado em 1. O código para fazer isso é algo parecido com isso:

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->visitas += 1;
    $post->save();
    $this->render('view', array('post' => $post));
}

Essa abordagem tem dois problemas. Queremos atualizar apenas a coluna visitas, mas todo o registro do post será atualizado. Além disse, caso o argumento false não seja passado para o método save, todo o processo de validação será executado.

Desde a versão 1.1.8, a classe CActiveRecord tem um método que pode nos ajudar com isso. Trata-se do método CActiveRecord::saveCounters() e a sua utilização é muito simples:

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->saveCounters(array('visitas'=>1));
    $this->render('view', array('post' => $post));
}

Com isso, somente a coluna visitas será atualizada e a validação não será disparada.

Caso você ainda não utilize a versão 1.1.8, você pode utilizar o método CActiveRecord::updateCounters():

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->updateCounters(
        array('visitas'=>1),
        array('condition' => "id = :id"),
        array(':id' => $this->id),
    );
    $this->render('view', array('post' => $post));
}

O trecho de código acima faz exatamente o mesmo que o saveCounters. Note que o método updateCounters tem dois parâmetros a mais. Depois de informar a coluna utilizada para contar, é preciso passar uma condição que diz qual registro deverá ser atualizado. Se você utilizou algum parâmetro nessa condição (como o “:id”), você também deve informar o valor dele, utilizando o terceiro argumento do método.

Importante: Se você não informar nenhuma condição, todos os registros serão atualizados.

The easier way to do that is by adding a column to the post table, which will be used to store the number of visits of that item. Each time the post is displayed the value of this column will be increased by 1. The code for this would be something like:

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->visits += 1;
    $post->save();
    $this->render('view', array('post' => $post));
}

We have two problems with this approach. All we want is to update the visits column, but the entire record will be updated. Also, if we didn’t pass the false argument to the save method, all the validation process will be executed.

Since 1.1.8, the CActiveRecord class has a method that can help us with this task. It’s the CActiveRecord::saveCounters() method and its usage is pretty simple:

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->saveCounters(array('visits'=>1));
    $this->render('view', array('post' => $post));
}

With this, only the visits column will be updated and the validation will not be triggered.

If you’re not using the 1.1.8 yet, there’s the CActiveRecord::updateCounters() method:

public function actionView($id) {
    $post = Post::model()->findByPk($id);
    $post->updateCounters(
        array('visits'=>1),
        array('condition' => "id = :id"),
        array(':id' => $this->id),
    );
    $this->render('view', array('post' => $post));
}

The piece of code above does exactly the same that saveCounters does. Note that updateCounters has two additional parameters. After the column used to count, we pass a condition to tell which record(s) should be updated. If you used any paramater in this condition (like the “:id”), you should pass the parameter value in the third argument of the method.

Important: If you do not pass a condition, all records will be updated.

Contudo, recentemente o disco do meu notebook começou a dar sinais de que está agonizando. Na verdade, não sei se trata-se apenas de problemas no sistema de arquivos ou um falha de hardware iminente, mas os constantes erros me trouxeram más lembranças e me deixaram com medo.

Desde a perda do primeiro HD, tenho procurado uma solução simples e eficiente para backups. Tenho pensando bastante em um NAS, com suporte a RAID ou um PC Mini-ITX. Enquanto o dinheiro não vem, e os erros aumentam, encontrei uma solução mais simples para o backup de meus arquivos, composta dos seguintes itens:

Incron
É um cron para o sistema de arquivos. Trabalha junto com o inotify e permite agendar comandos que são executados como resposta a eventos em diretórios e arquivos. Utilizo ele para monitorar os itens que quero manter no backup.

Rsync
É um programa utilizado para manter a sincronização de arquivos entre dois diretórios diferentes. A grande sacada é a possibilidade de realizar transferência incremental de arquivos. Ou seja, são sincronizados apenas os itens que sofreram alterações. Na minha solução de backup, utilizo ele para sincronizar os arquivos e diretórios que desejo efetuar backup com o diretório do Dropbox.

Dropbox
O Dropbox é um serviço online de armazenamento de arquivos. Na versão gratuita são oferecidos 2Gb de espaço em disco. Seu instalador possui um daemon que monitora um determinado diretório em seu computador. Qualquer alteração nesse diretório é atualizada na sua cópia online.

Como instalar?
Aqui, no Arch Linux, o processo de instalação foi bastante simples. O incron e o rsync estão disponiveís nos repositórios community e extra, respectivamente. Já o dropbox está disponível no AUR. Para instalar tudo, bastou o comando:

$ yaourt -S incron rsync dropbox

Configurando
Antes de tudo, precisamos configurar o Dropbox. Ele deve estar localizado em Aplicativos -> Internet -> Dropbox. Na primeira execução você poderá configura-lo com os dados de sua conta, caso já possua uma, ou criar um nova. Por fim, selecione o diretório que será monitorado pelo daemon.

Agora que você já possui um diretório em seu computador ligado a sua conta do Dropbox, precisamos fazer com que as atualizações nos itens que deseja realizar backup sejam replicadas para o diretório do serviço de armazenamento. Para monitorar essas atualizações vamos utilizar o incron.

Aqui não foi necessário nenhuma configuração do daemon. Entretanto é necessário adiciona-lo a lista de inicialização de daemon no arquivo /etc/rc.conf. Feito isso, basta adicionar as entradas no incrontab, indicando qual diretório/arquivo monitorar, em quais eventos e qual ação a ser executada. Para editar o incrontab, digite:

$ incrontab -e

Umas das entradas em meu arquivo é:

/home/davi/Documentos IN_CREATE,IN_DELETE,IN_MODIFY,IN_MOVE rsync -a --delete /home/davi/Documentos /home/davi/Dropbox/backup

Com isso, indico que o incron deve monitorar o diretório /home/davi/Documentos e, cada vez que um arquivo ou diretório seja criado, removido, modificado e movido, deverá executar o comando rsync, sincronizando o diretório monitorado com o diretório /home/davi/Dropbox/backup. Assim que a sincronização for concluída o daemon do Dropbox se encarregará de enviar seus arquivos para o armazenamento online, concluindo o backup.

Após realizar qualquer alteração no incrontrab é necessário recarregar o arquivo através do comando:

$ incrontab -d

Pronto! Assim concluímos a criação de um sistema simples e prático para backup automático. Por enquanto, pretendo continuar utilizando o Dropbox para armazenar meus arquivos. Futuramente, caso mude a forma de armazenamento, os ajustes necessários serão simples. Na verdade, será necessário apenas alterar o comando rsync para ter como destino o novo local para onde deverá enviar os arquivos.

Trata-se de um player leve, escrito em python e utilizando GTK. Sem frescuras, tem poucos recursos, praticamente todos os que eu utilizava no Amarok. Até a interface lembra bastante a versão antiga do meu último player. Entretanto senti falta de uma funcionalidade: Preencher as tags do arquivo com informações do Musicbrainz. É comum ter arquivos com tags fora de padrão, ou até mesmo sem nenhuma informação nelas e arrumar isso na mão é um saco. Para resolver o problema, criei um plugin!

Com o plugin Musicbrainz basta selecionar uma música em sua playlist, clicar com o botão direito e selecionar “Fill tags with MusicBrainz suggestions”. Irá surgir uma janela, como na imagem abaixo:

As sugestões estão ordenadas por score. Quanto maior o escore, maior a probabilidade de ser a correta. Para preencher as tags de seu arquivo, basta selecionar a opção que melhor se encaixe no seu caso e clicar em “Save”.

Sim, o plugin trabalha apenas com uma música por vez. A idéia não é arrumar toda a sua coleção, mas sim corrigir um ou outro erro em um arquivo. Para recursos mais elaborados você pode utilizar o Picard, da própria Musicbrainz. Entretanto, quem sabe em futuras versões não tenha uma versão mais completa? ;D

Para baixar o plugin utilize o link abaixo. No Exaile, para instalar, vá em Edit > Preferences > Plugins. Clique em Install Plugin File e selecione o arquivo em seu computador. Por fim, habilite o Musicbrainz na lista de plugins!

Trata-se de uma liguagem “meio frankestein”, com uma sintaxe com características de C/C++, Python, Ruby e alguma outra coisa que eu não consigo identificar.

GO é uma linguagem compilada e, até o momento, existem compiladores apenas para ambientes *nix. Acabo de instalar aqui no meu Xubuntu e o processo foi bastante simples.

Primeiro é necessário configurar algumas variáveis de ambiente:

• $GOROOT – A raiz da estrutura de diretórios do GO. Vamos utilizar $HOME/go.
• $GOOS  – O sistema operacional que estamos utilizando. No meu caso linux.
• $GOARCH – A arquitetura do sistema operacional. No meu caso 386. Para quem tem sistemas 64bits, utilize amd64.
• $GOBIN – Essa é opcional e trata-se do diretório onde ficarão os binários do GO. Por padrão utiliza o diretório $HOME/bin, que já deve estar em seu PATH e existir.

Para adicionar essas variáveis ao seu sistema, edite o arquivo ~/.bashrc:

$ vim ./bashrc

No fim do arquivo adicione as seguintes linhas:

export GOROOT=$HOME/go
export GOOS=linux
export GOARCH=386
export PATH=$PATH:$HOME/bin

Caso o diretório $HOME/bin não exista, você deverá cria-lo. É preciso sair e entrar novamente no terminal para que essas alterações tenham efeito.

Com o sistema configurado, precisamos instalar algumas ferramentas para compilar o compilador do GO. Utilize:

$ sudo apt-get install mercurial bison gcc libc6-dev ed

Com as ferramentas instaladas, devemos baixar o código fonte do repositório do GO. Utilize:

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Ao término da cópia dos arquivos, entre no diretório $GOROOT/src:

$cd $GOROOT/src

E execute:

$ ./all.bash

Aguarde a compilação. Ao término, caso tudo ocorra bem você deverá ler a mensagem:

--- cd ../test
N known bugs; 0 unexpected bugs

Podem acontecer alguns erros durante a compilação. Aqui, ocorreu um durante a teste da lib net, onde é realizada uma tentativa de conexão com o google. Nesse caso, bastou indicar ao processo que essa biblioteca não deveria ser testada. Para isso, editei o arquivo $GOROOT/src/pkg/Makefile, e, no item NOTEST, adicione um novo item “net\”. Por fim, executei novamente all.bash.

Pronto, agora você já pode começar a brincar com a nova linguagem. Para compilar utilize:

$ 8g arquivo.go && 8l arquivo.8

Será criado o executavel arquivo.out.

Caso utilize um sistema 64bits, troque o 8 pelo 6:

$ 6g arquivo.go && 6l arquivo.6

Agora, restar estudar a linguagem e ver do que ela é capaz =D

Para mais informações, alguns links:

• Tutorial – Resumo geral da linguagem. Ideal para quem está começando.
• Effective GO – Documentação detalhada sobre a sintaxe da linguagem.
• Documentação dos comandos
• Documentação dos pacotes e bibliotecas
• Lista de discussão GO-Nuts

Como a Kennex, em um raro momento de sabedoria, não considera a troca de sistema operacional um procedimento que viola a garantia do produto, a primeira coisa que fiz foi remover o Insigne Linux que vem instalado no notebook e instalar o Windows 7 em dual boot com o Ubuntu 8.10.

A instalação do Windows 7 ocorreu sem nenhum problema. Tudo funcionando perfeitamente nesse sistema. Ao término da instalação somente foi necessário instalar os drivers da placa de rede com e sem fio.

Já para a instalação do Ubuntu são necessárias algumas configurações.

Ao inicializar o computador através do live cd, será preciso apertar a tecla F6, para selecionar outras opções de boot. Marque a opção “nolapic”. Somente assim você conseguirá iniciar  e instalar o sistema através do cd.

Após instalar o sistema não será possível dar boot pelo Ubuntu. Para isso, serão necessárias algumas configurações no GRUB, o gerenciado de boot utilizado pelo Ubuntu.

Ao iniciar, quando exibida a tela de opções para escolher o sistema operacional a ser iniciado, selecione o Ubuntu e pressione a tecla “e”, para editar as opções de boot. Você deverá adicionar ao final da terceira linha, os seguintes parâmetros:

noapic pci=assign-busses apicmaintimer idle=poll

Feito isso, pressione “b”, para iniciar o sistema.

Com o Ubuntu em execução, adicione os mesmos parâmetros diretamente ao arquivo menu.lst de seu GRUB. Para isso acesse o seu terminal (Aplicativos > Acessórios > Consola), e execute o comando:

sudo su

Assim você ganhará permissões de administrador para executar as alterações necessárias no arquivo. Para edita-lo  execute:

vim /boot/grub/menu.lst

Procure neste arquivo pela mesma linha que você editou na inicialização do computador. Por padrão, ela deve ser a 4ª linha encontrada logo abaixo do texto:

## ## End Default Options ##

Lá, assim como feito antes, você deverá adicionar os parâmetros de inicialização citados acima. Para habilitar a edição de textos no Vim, você deve pressionar a tecla “i”.

Para salvar as alterações, pressione “esc” e, em seguida, digite :wq e pressione “enter”. Pronto! Todas as alterações necessárias foram realizadas. Agora seu sistema operacional poderá ser iniciado sem nenhum problema.

O Ubuntu é uma excelente escolha para esse notebook!. Tudo funciona perfeitamente, sem necessidade de nenhuma configuração.

Logo mais irei fazer uma análise mais detalhada do novo notebook, que, já adiantando, tem uma performance bastante impressionante!

Durante esse período de transição, a equipe de TI do Metrô desenvolveu algumas apostilas utilizadas para treinamentos dos funcionários da empresa. Seguindo a filosofia do software livre, as apostilas desenvolvidas foram disponibilizadas livremente para download no seguinte endereço:

http://www.metro.sp.gov.br/diversos/download/tedownload.asp

Na página acima é possível encontrar apostilas de GIMP, Gantt Project, Firefox, Thunderbird e OpenOffice.

Lá você encontra o Listutorial, um tutorial mostrando o básico sobre formatação de listas com CSS. Além disso temos o Listmatic e o Listmatic2. Nessas seções o pessoal da maxdesign parte da idéia de “Uma lista, muitas opções” e mostram como é possível, a partir de uma simples lista, criar os mais diversos tipos de menus. Em Listmatic, existem vários exemplos utilizando um lista não ordenada simples, já em Listmatic2 os exemplos utilizam uma lista não ordenada aninhada.

Todos os exemplos utilizam apenas CSS e HTML e possuem uma tabela de compatibilidade com navegadores.

Foi assim que resolvi desenvolver um script para baixar imagens de sites. Várias vezes gastei meu dedo, clicando com o botão direito do mouse sobre imagens e mais imagens e escolhendo “salvar como”. Agora, com o script, basta apenas informar a url da página com as imagens e todo o trabalho é feito em alguns segundos (ou minutos, dependendo do tamanho da imagem):

import urllib
import re

for img in re.findall("<img .*?src=\"(.+?)\"", urllib.urlopen("http://www.uol.com.br&quot;).read()):
    arq_imagem = open(img[img.rfind('/') + 1:], 'wb')
    arq_imagem.write(urllib.urlopen(img).read())
    arq_imagem.close()

O legal é que o código acima pode facilmente ser convertido para baixar imagens de toda uma galeria. Por exemplo, imagine um site onde a galeria siga um padrão para urls como este:

http://www.exemplo.com.br/galerias/0001/imagens.html

Para baixar, por exemplo, as 100 primeiras galerias:

import urllib
import re

for galeria in range(100):
    url = "http://www.exemplo.com.br/galerias/" + ("%04d" % (galeria + 1)) + "/imagens.html"

    for img in re.findall("<img .*?src=\"(.+?)\"", urllib.urlopen(url).read()):
        arq_imagem = open(img[img.rfind('/') + 1:], 'wb')
        arq_imagem.write(urllib.urlopen(img).read())
        arq_imagem.close()

    galeria += 1