Basicamente o htaccess utiliza a mesma sintaxe do arquivo de configuração principal do Apache, porém obedece as regras estabelecida pela diretriz AllowOverride.

Para utiliza-lo crie um arquivo ".htaccess" no diretório onde você deseja que as regras sejam aplicadas e adicione dentro dele as diretrizes. As regras são aplicadas sem a necessidade de reiniciar o Apache.

Quando utilizar?

Por questões de performance e segurança: NUNCA!!!!!!!!!!!!11...

Obviamente se o htaccess existe é porque há um motivo. Utilize nas seguintes condições:

• Se sua hospedagem não permitir alterações nas configurações principais do Apache (permissão).
• Se você precisar permitir que seus usuários possam alterar as configurações do Apache (ex: servidor compartilhado), mas com uma certa limitação (hospedagem é um bom exemplo novamente).

De toda forma evite o uso do htaccess.

Dicas

As dicas abaixo funcionam não só no ".htaccess", mas também no arquivo de configuração principal do Apache (onde é mais recomendável).

Algumas dicas podem necessitar do módulo Mod-Rewrite habilidado.

301 Redirect

O "301 redirect" é a melhor forma de ser fazer um redirecionamento de uma página, além de Search Engine Friendly.

Exemplo 1: Redirecionando todo o website para um outro domínio

Redirect 301 / http://outrodominio.com.br/

Exemplo 2: Redirecionando uma página específica

Redirect 301 /pagina_de.html http://dominio.com.br/pagina_para.html

404 Redirect

Redirecionando erros 404, o famoso "Page not found" (Página não Encontrada), para um outra página.

ErrorDocument 404 /pagina_404_customizada.html

O mesmo vale para redirecionar outras página de erro como 403, 500 e 666. o.O

DirectoryIndex

A diretriz "DirectoryIndex" permite escolher uma lista de recursos/páginas/arquivos que serão retornados para a requisição de um index de diretório. Se o arquivo index não for especificado será feita a listagem do diretório (se for permitido).

Por padrão é procurado pelo "index.html" (ou index.php ou outras extensões mais caóticas).

Exemplo:

• De http://seudominio.com.br/ para http://seudominio.com.br/index.html
• De http://seudominio.com.br/diretorio/ para http://seudominio.com.br/diretorio/index.html

DirectoryIndex index.html index.txt index.exe

Negando listagem de diretório

Já que eu comentei, para não permitir a listagem de diretórios adicione o seguinte comando no htaccess.

Options -Indexes

Mudando extensões dos arquivos

Se você quiser migrar/trocar suas páginas *.html para *.php poderá utilizar o seguinte comando.

RedirectMatch 301 (.*)\.html$ http://www.seudominio.com.br$1.php

Só fique esperto com o uso de iframes

Tradução do Google

Traduz o site automaticamente através do Google Translate. Este até que é interessante (apesar de ainda não ter pensado em como poderá ser útil) e encontrei hoje no site da Dreamhost.

Fiz alterações para que seja de Português para outros idiomas e aviso que ainda não testei.

Options +FollowSymlinks
RewriteEngine On
RewriteBase /
RewriteRule ^(.*)-(en|es|it|jp|fr)$ http://www.google.com/translate_c?hl=$2&sl=pt&u=http://seudominio.com.br/$1 [R,NC]

Funciona da seguinte forma, quando alguém acessar "http://seudominio.com.br/-en" ele será traduzido de Português(pt) para Inglês(en) pelo Google Translate.

AccessFileName

Permite alterar o nome do arquivo htaccess (que por padrão é ".htaccess") para qualquer outra coisa como ".config". Esta diretriz na verdade deve ser utilizada no arquivo de configuração principal do Apache.

AccessFileName .config

O make (GNU make) é uma ferramenta que executa os comandos inclusos dentro de um arquivo. É normalmente utilizado na compilação e instalação de programas.

Uma das vantagens do make é que ele identifica quais partes do programa devem ser recompiladas de acordo com as mudanças efetuadas desde a última compilação.

Dependendo do tamanho do programa pode-se economizar minutos ou horas entre as recompilações, pois não será necessário recompilar o programa inteiro.

Exemplo de uso:

$ make -f arquivo_com_os_comandos

Se você chamar o comando make sem passar nenhum parâmetro ele tentará utilizar o arquivo com nome de Makefile do diretório atual.

É o que normalmente acontece quando você precisa compilar e instalar um programa pelo código fonte.

• Descompactar o código fonte (se for um "*.tar.gz").
• Entrar na pasta descompactada. Haverá um arquivo Makefile dentro.
• Executar o comando "make" para compilar.
• Executar o comando "make install" como root para instalar.

Makefile

Se você quiser utilizar o comando make só é necessário criar um arquivo Makefile e dentro dele colocar as instruções que o make deve executar.

Formato do Makefile:

regra: dependências...
	comandos
	...

Os comandos são comandos normais do shell (bash). Pode-se colocar vários comandos, porém devem estar identados com tabulações. Isto é importante, não utilize espaços pois não irá funcionar.

A regra é só um nome para identificar um bloco de comandos. Fazendo uma analogia com programação, a "regra" seria semelhante a uma função.

As dependências são os arquivos necessários para a execução dos comandos da regra, o make irá fazer a verificação deles. Também podem ser outras regras que serão chamadas antes da execução dos comandos. Se houver mais de uma dependência elas devem ser separadas com espaços.

Aqui vai um exemplo de um Makefile que compila um programa em C:

program:
	gcc -o meuprograma meuprograma.c

Um exemplo com dependências:

program: cod1.c cod2.c lib1.a
	gcc -c cod1.c cod2.c
	gcc cod1.o cod2.o lib1.a -o program

lib1.a: lib1.c cod3.c
	gcc -c lib1.c cod3.c
	ar rcs lib1.a lib1.o cod3.o
	ranlib lib1.a

Pode-se utilizar variáveis também. A declaração é simples, mas devem ser chamados com a notação "$(variável)". Repare também que elas podem ser concatenadas:

CC=gcc
CFLAGS=-O2
CFLAGS=$(CFLAGS) -Wall

program:
	$(CC) $(CFLAGS) -o program program.c

Olha que legal no Makefile a seguir, advinha o que acontece ao executar o comando `make clean' no terminal?

program: program.c
        gcc -o program program.c

clean:
        rm *.o
        rm program

O que aconteceria também se houvesse um arquivo no diretório atual que se chamasse "clean"? O `make clean' não iria executar a lista de comandos da regra. Para evitar este tipo de conflito utilize a regra ".PHONY":

program: program.c
        gcc -o program program.c

.PHONY: clean
clean:
        rm *.o
        rm program

Agora a regra "clean" será executada mesmo se houver um arquivo no diretório atual com mesmo nome.

No código, basta adicionar o javascript e o css do tablesorter, além da biblioteca jquery:

 
<html>
<head>
<link rel="stylesheet" type="text/css" href="tablesorter.css" />
    <script type="text/javascript" src="jquery.js"></script>
    <script type="text/javascript" src="jquery.tablesorter.js">
    </script>
    <script type="text/javascript">
        $(function(){
             $('.tablesorter').tablesorter()
         })
    </script>
</head>
<body>
<table class="tablesorter" cellspacing="1">
<thead>
<tr>
<th>first name</th>
<th>last name</th>
<th>age</th>
<th>total</th>
<th>discount</th>
<th>date</th>
</tr>
</thead>
<tbody>
<tr>
<td>peter</td>
<td>parker</td>
<td>28</td>
<td>$9.99</td>
<td>20%</td>
<td>jul 6, 2006 8:14 am</td>
</tr>
<tr>
<td>john</td>
<td>hood</td>
<td>33</td>
<td>$19.99</td>
<td>25%</td>
<td>dec 10, 2002 5:14 am</td>
</tr>
<tr>
<td>clark</td>
<td>kent</td>
<td>18</td>
<td>$15.89</td>
<td>44%</td>
<td>jan 12, 2003 11:14 am</td>
</tr>
<tr>
<td>bruce</td>
<td>almighty</td>
<td>45</td>
<td>$153.19</td>
<td>44%</td>
<td>jan 18, 2001 9:12 am</td>
</tr>
<tr>
<td>bruce</td>
<td>evans</td>
<td>22</td>
<td>$13.19</td>
<td>11%</td>
<td>jan 18, 2007 9:12 am</td>
</tr>
</tbody>
</table>
 
<body>
</html>
 

Na documentação oficial ainda, são listadas algumas das configurações possíveis, dentre as quais podemos destacar:

• Forçar ordenação inicial
• Ordenar tabela com link fora dela
• Adicionar conteúdo dinâmicamente a tabela com AJAX
• É possível criar um parser para ordenar conteúdo com seu próprio critério
• Integração com plugin de paginação

É isso ai

Vamos ao nosso primeiro exemplo de carrossel:

Para fazer um carrossel simples, como este, precisaremos dos arquivos de js e css da biblioteca jCarousel, além do css de skin do jCarousel a ser utilizado, e do js do jQuery. Segue o código:

 
<html>
<head>
<title>Carrossel simples com jQuery</title>
<link rel="stylesheet" type="text/css" href="css/style.css" />
<link rel="stylesheet" type="text/css" href="css/jcarousel.css" />
<link rel="stylesheet" type="text/css" href="css/tango-skin.css" />
<script type="text/javascript" src="js/jquery.js"></script>
<script type="text/javascript" src="js/jcarousel.js"></script>
<script type="text/javascript">
$(function(){
    $('#carrossel').jcarousel()
})
</script>
</head>
<body>
<h1>jCarousel - Carrosel Simples</h1>
<ul id="carrossel" class="jcarousel-skin-tango">
<li><img src="img/imagem1.jpg" /></li>
<li><img src="img/imagem2.jpg" /></li>
<li><img src="img/imagem3.jpg" /></li>
<li><img src="img/imagem4.jpg" /></li>
<li><img src="img/imagem5.jpg" /></li>
<li><img src="img/imagem6.jpg" /></li>
</ul>
 
</body>
</html>
 

Este é o exemplo mais simples de utilização do jCarousel, existem várias outras variações deste através de opções passadas a ele. Dentre as funcionalidades podemos destacar:

• Carrossel Vertical
• Carrossel com scroll automático
• Carrosel com controles estáticos
• Carrossel com conteúdo dinâmico via AJAX utilizando a API do Flickr
• Scroll de Textos
• Carrossel e Thickbox (clique na imagem do carrossel)

Eu sempre achei um saco o fato do Django não ter um módulo builtin/contrib que permitisse que ao fazer um simples logging.error('PAN!') a mensagem, a data, o nível, the universe and everything, fossem gravados no banco de dados. Pra resolver esse simples problema, nada como uma simples solução.

A Solução

Para começar crie um aplicativo em sua aplicação chamado "log", nunca crie a aplicação com nome de "logging", a não ser que você queira problemas com imports não funcionando:

python manage.py startapp log

Em seguida crie o seguinte model:

# -*- encoding: utf-8 -*-
from django.db import models
from django.contrib import admin
import logging
 
class Log(models.Model):
    level = models.IntegerField(db_index=True)
    file = models.CharField(max_length=512, db_index=True)
    lineno = models.IntegerField()
    date = models.DateTimeField(db_index=True)
    message = models.TextField()
 
    def _get_level_name(self):
        return logging.getLevelName(self.level)
    levelName = property(fget=_get_level_name)
 
    def _get_message_summary(self):
        if len(self.message) > 100:
            return '%s...'%(self.message[:100])
        else:
            return self.message
    messageSummary = property(fget=_get_message_summary)
 
    def _get_file_summary(self):
        if len(self.file) > 30:
            return '...%s'%(self.file[-30:])
        return self.file
    fileSummary = property(fget=_get_file_summary)
 
class LogAdmin(admin.ModelAdmin):
   date_hierarchy = 'date'
   list_display = ('level', 'levelName', 'date','messageSummary', 'fileSummary', 'lineno')
   list_filter = ('level',)
   search_fields = ('message', 'file')
 
admin.site.register(Log, LogAdmin)
 

Em seguida crie o arquivo "handler.py" dentro do aplicativo "log" com o seguinte conteúdo:

 
# -*- encoding: utf-8 -*-
import logging
import datetime
from SEUPROJETO.log.models import Log
 
class DjangoHandler(logging.Handler):
    '''Executa a manipulação do log e insere no banco de dados'''
    def emit(self, record):
        log = Log()
        log.level = record.levelno
        log.file = record.pathname
        log.lineno = record.lineno
        log.message = record.msg
        # TODO: Utiizar o record.created
        log.date = datetime.datetime.now()
        log.save()
 

Com isso você já tem tudo que precisa pra logar direto pro banco de dados, só falta uma coisa: Configurar o projeto para o logging usar nosso handler.

Pra fazer isso, edite o arquivo __init__.py (e você achando que esse arquivo era inutil e adicione o seguinte conteúdo ao arquivo:

 
import logging
from SEUPROJETO.log.handler import DjangoHandler
django_handler = DjangoHandler()
logging.root.addHandler(django_handler)
 

E pronto, é só correr pro abraço, todo e qualquer log que você executar vai ser armazenado no banco de dados.

Yes! Tudo que faltava pra terminar meu projeto!

... e antes que você venha me reclamar que a p0rr@ do log não ta aparecendo em lugar nenhum, verifique se você está usando o logging.debug com a configuração padrão do módulo logging (que só exibe mensagens de nível mais alto).

Em tempo: Eu sei que é extremamente simples criar um módulo/pacote com tudo isso, mas não seria tão didatico simplesmente falar "baixe aqui, copie ali e import lá".

Se você tiver interesse, sugira a implantação deste módulo ao django.contrib

Atualmente temos uma diversidade de conteúdo espalhado sob diversas formas, seja através de fotos, comentários, tweets, blogs, links favoritos, etc. Como exemplo podemos citar as redes: Flickr, Last.fm e Twitter.

Não seria interessante agregá-los em uma página ?

Isso pode ser feito utilizando a classe SimplePie, de código aberto, fácil utilização, escrita em PHP e que nos ajudará a trabalhar com o RSS necessário para a manipulação dos dados.

Ela pode ser encontrada em: http://simplepie.org/downloads/.

Utilização

Primeiramente precisamos coletar os feeds desejados.

Para isso, acesse seus perfis (ou de quem você deseja seguir) e guarde as URLs que geralmente estão nos ícones de RSS.

Precisamos realizar um simples teste de compatibilidade (já disponível no pacote) para verificarmos se o servidor que rodará a aplicação oferece suporte completo à classe. Esse teste encontra-se na pasta "compatibility_test".

Devemos criar uma pasta para o cache da aplicação. Basicamente ela armazenará certificados.

Exemplo

Definindo path da classe e variáveis de configuração

<?php
require_once('./simplepie/simplepie.inc');
 
$cache = "./rsscache";
$duration = 2000;

Definindo os feeds

// Para o blog e twitter utilizamos o perfil da Stiod, como exemplo
$blog = new SimplePie("http://blog.stiod.com/rss.xml", $cache, $duration);
$twitter = new SimplePie("http://twitter.com/statuses/user_timeline/17368651.rss", $cache, $duration);
// Substitua PERFIL pelo desejado
$lastfm = new SimplePie("http://ws.audioscrobbler.com/2.0/user/PERFIL/lovedtracks.rss", $cache, $duration);

Função para transformar os nomes em links diretos

 
 function twitterify($ret) {
   $ret = preg_replace("#(^|[\n ])([\w]+?://[\w]+[^ \"\n\r\t< ]*)#", "\\1<a href=\"\\2\">\\2</a>", $ret);
   $ret = preg_replace("#(^|[\n ])((www|ftp)\.[^ \"\t\n\r< ]*)#", "\\1<a href=\"http://\\2\">\\2</a>", $ret);
   $ret = preg_replace("/@(\w+)/", "<a href=\"http://www.twitter.com/\\1\">@\\1</a>", $ret);
   $ret = preg_replace("/#(\w+)/", "<a href=\"http://search.twitter.com/search?q=\\1\">#\\1</a>", $ret);
   return $ret;
 }
 

Para carregarmos os itens, utilizamos uma estrutura de repetição como a seguinte

<?php foreach ($twitter->get_items() as $item) : ?>
<li>
 
<?php echo twitterify(str_replace("raena: ", "", $item->get_title())); ?>
 
<a href="<?php echo $item->get_link(); ?>"><?php echo $item->get_date(); ?></a>
</li>
 
<?php endforeach; ?>

Baixe o exemplo completo do agregador

Esse foi um exemplo básico, entretanto, não ficamos restritos ao exposto, é possível fazermos aplicações com maiores funcionalidades.

Para isso, acesse o Wiki, onde existem inclusive plugins para a extensão da classe.

Hoje vou mostrar um pouco sobre Effects e alguns métodos interessantes do jQuery, Usando como exemplo um simples slide de Imagem.

Neste código vemos o effect FadeIn(efeito de aparecer) e fadeOut(efeito de desaparecer) e o método next

 
function slidein(){
    active_img = $(".active");
    //O método next pega o próximo objeto,  dentro do div #slide-img
    next_img =active_img.next();
 
    // verifica se existe um próximo objeto no div #slide-img
    if (next_img.length==0){
            //se não tem um próximo objeto retorna pro primeiro
            next_img = $(".first-active");
    }
 
    active_img.fadeOut("slow");
    active_img.removeClass('active');
 
    next_img.fadeIn("slow");
    next_img.addClass('active');
}
 
$(document).ready(function(){
setInterval("slidein()", "3500");}
)
 

O HTML para o slide de imagem deve ser o seguinte:

 
<div id="slide-img">
<ul>
<li class="active first-active"><img src="img1.jpg"/></li>
<li><img src="img2.jpg" /></li>
<li><img src="img3.jpg" /></li>
</ul>
</div>
 

Antes coloque esse trecho de CSS:

 
#slide-img {
    float:left;
    height:xxx px;/* a largura padrão das imgs dentro do slide*/
    overflow:hidden;
    width:yyy px;/* o altura padrão das imgs dentro do slide*/;
}
* {
    margin:0;
    padding:0;
}
 

Veja o exemplo aqui:

O ideal que o tamanho das imagens dentro do slide sejam as mesmas

E como funciona?

Para adicionar bordas arredondas basta você adicionar a biblioteca do jquery na sua página e o arquivo js do plugin:

 
<html>
<head>
<title>JQuery Corner</title>
// Jquery
<script src="jquery.js" type="text/javascript"></script>
// JQuery Corner
<script src="jquery.corner.js" type="text/javascript"></script>
<script type="text/javascript">
$(function(){     
    // Arredonda a borda do elemento com id borda-arredondada
    $('#borda-arredondada').corner() 
})
</script>
</head>
<body>
<div id="borda-arredondada">
Lorem ipsum dolor sit amet
</div>
 
</body>
</html>
 

Segue o exemplo:

Você ainda pode passar parâmetros para colocar bordas com certo tamanho de arredondamento, ou somente no topo, em baixo, ou outras "formas de arredondamento":

 
// Borda de 30px em todas as pontas
$("#borda-arredondada').corner('30px')
// Somente no topo
$("#borda-arredondada').corner('top')
// Somente em baixo
$("#borda-arredondada').corner('bottom')
// Somente no topo direito (tr = top + right)
$("#borda-arredondada').corner('tr')
// Bevel
$("#borda-arredondada').corner('bevel')
 

Outros exemplos podem ser vistos no site http://www.malsup.com/jquery/corner/.


É isso ai

De início você pode estar pensando: "mas porquê vou incluir essa biblioteca se o PHP já possui a função mail() nativamente ?".

Através da classe PHPMailer, temos uma solução de envio de email mais robusta e com maiores funcionalidades, dentre elas a possibilidade de incluir anexos à mensagem, incluir CCs e CCOs, definir tamanho padrão para quebra de palavras (wordwrap) e utilizar um servidor SMTP, sendmail ou QMail para o envio.

O fato de podermos especificar como será feito o envio é particularmente útil no caso de hospedarmos uma aplicação em um ambiente que não possua um servidor de email integrado (cenário incomum mas que pode vir a ocorrer). Nesse caso, é possível, ainda, definirmos um host padrão para envio e um outro redundante, no caso de o primeiro falhar.

Onde encontrar

O download da biblioteca pode ser feito em: http://sourceforge.net/projects/phpmailer/files/.
Nesse endereço existem versões para o PHP 4 e PHP 5.

Exemplo de utilização (adaptado do leiame do projeto):


Configurações de envio

<?php
    require("class.phpmailer.php");
    $mail = new PHPMailer();
    // configuramos o mailer para utilizar SMTP
    $mail->IsSMTP();
    // especificamos o servidor principal e o reserva
    $mail->Host = "smtp1.example.com;smtp2.example.com";
    // ativamos a autenticação no SMTP
    $mail->SMTPAuth = true;
    // usuário(s) de SMTP
    $mail->Username = "usuario_smtp1;usuario_smtp2";
    // senha(s) de SMTP
    $mail->Password = "senha_smtp1;senha_smtp2";

Cabeçalho e conteúdo da mensagem

    /* podemos utilizar qualquer idioma presente na pasta languages,
    facilitando uma eventual depuração de erros */
    $mail->SetLanguage("br");
    $mail->From = "from@example.com";
    $mail->FromName = "Mailer";
    // o nome é opcional
    $mail->AddAddress("josh@example.net", "Josh Adams");
    // quebra de palavra em 50 caracteres
    $mail->WordWrap = 50;
    // anexo - nome é opcional
    $mail->AddAttachment("/tmp/image.jpg", "new.jpg");
    // configuramos o formato de email como HTML
    $mail->IsHTML(true);
    $mail->Subject = "Este é o assunto";
    $mail->Body    = "Este é o corpo da mensagem HTML <b>em negrito!</b>";
    $mail->AltBody = "Este é o texto puro para clientes de email que não suportam HTML";

Envio do email

    if(!$mail->Send())
    {
        echo "A mensagem não pôde ser enviada.<br/>";
        echo "Erro: " . $mail->ErrorInfo;
        exit;
    }
    echo "Mensagem enviada !";
?>

Instalação no Linux
Baixe o código fonte da última versão aqui.

Descompacte com o comando:
$ tar -zxvf python-twitter-XXX.tar.gz

Após descompactar entre no diretório criado e execute o seguinte comando como usuário root:
# python setup.py install


Utilização
Para utilizar a API importe o módulo twitter:

import twitter
...

As principais classes que você deve conhecer são:
twitter.Api
twitter.User
twitter.Status
twitter.DirectMessage

Para iniciar, crie uma instancia da classe twitter.Api:

import twitter
api = twitter.Api()

Com este objeto você pode utilizar os métodos da API que não necessitam de autenticação do usuário. Um Exemplo é o método GetPublicTimeline, que sem parâmetros retorna as últimas 20 mensagens de status dos usuários.

import twitter
api = twitter.Api()
status_list = api.GetPublicTimeline()
for status in status_list:
    print status.user.name

No exemplo anterior o status é um objeto da classe twitter.Status. A classe twitter.Status possui um atributo user que é um objeto da classe twitter.User.

Para realizar a autenticação de um usuário, instancie a classe twitter.Api, porém passando o usuário e a senha como parâmetros:

import twitter
api = twitter.Api(username='joao', password='abc123')

Para enviar uma mensagem utilize o método PostUpdate:

# -*- encoding: utf-8 -*-
import twitter
api = twitter.Api(username='joao', password='abc123')
status = api.PostUpdate('''Yohohoho! Enviei uma mensagem! Mas cuidado
com os limite de 140 caracteres.''')

Repare que ele retorna o status da mensagem enviada.

Várias mensagens contínuas
Um método interessante da API é o PostUpdates, que permite que seja enviada uma mensagem com mais de 140 caracteres. A mensagem na verdade é enviada como se fosse várias mensagens com no máximo 140 caracteres.

Você também pode indicar uma string de continuação no segundo parâmetro, esta string é colocada no final das mensagens para indicar a continuação.

# -*- encoding: utf-8 -*-
import twitter
api = twitter.Api(username='joao', password='abc123')
status = api.PostUpdates('''Yohohoho! Enviei uma mensagem bem grande!
Agora você não precisa se preocupar com o tamanho da mensagem pois
este método irá dividi-la para você em várias mensagens, você também
pode utilizar uma string de continuação ao lado.''', '…')

Obs: Segundo a documentação da API, o Twitter remove as reticências ("...") das strings das mensagem, por isso utilize o caractere UNICODE \u2026 ("…"). Também não ultrapasse o limite dos 150 requests permitidos por hora pelo Twitter.