jah usaram o date -d , certo ?

date -d "1 hour ago"
date -d "1 day ago"

etc…

agora, e pra fazer 1 hora ou 1 dia adiante ?
after ? next ?

simples:

date -d "1 day"
date -d "1 hour"

Enviado por Alex:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/env python
 
import sys
 
def func1(arg):
    print 'here is func1: %s' % arg
 
def func2(arg):
    print 'here is func2: %s' % arg
 
funcptr = {
    'aa': func1,
    'bb': func2,
}
 
if __name__ == '__main__':
    try:
        funcptr[sys.argv[1]](sys.argv[2])
    except IndexError:
        print 'use: %s [%s] str' % (sys.argv[0], '|'.join(funcptr.keys()))

é comum pensar primeiro em if e logo em seguida em case.

Mas isso alem de ser ‘feio’ e complicar a leitura/compreensao do codigo, torna dificil sua manutencao.

Para isso existe o conceito de handler de funcoes, onde se cria uma estrutura com 2 campos:

o nome da funcao que sera utilizado para fazer o match com o comando (o nome do comando deve ser o mesmo que o comando informado), e um campo void que é um ponteiro para a funcao propriamente dita:

1
2
3
4
5
6
7
8

typedef struct {
   char *name;
   void (*func)(char *what, char *which, int connfd);
} handler_t;
 
const handler_t handlers[] = {
       {"add","add"}, {NULL}
};

crei um estrutura (handler_t) com o campo ‘name’, e o campo ‘(*func)’ o
‘(char *what, char *which, int connfd);’ sao os argumentos da funcao, claro q vc deve alterar para as suas necessidades.
logo em seguida eu defini um vetor do tipo ‘handler_t’ (minha estrutura) que contem um unico comando dentro:
add. Neste caso coloquei o name com o mesmo nome da funcao, isso pq claro, a funcao tem nome ‘add’.
agora pra fazer o match eh o mais simples:

1
2
3
4
5

for(i=0; handlers[i].name != NULL; i++)
{
	if(strcmp(handlers[i].name, cline.cmd) >= 0)
        	handlers[i].func(cline.what, cline.which);
}

Ou seja, ele cai na iteracao, e enquanto o campo ‘name’ nao for NULL, ele vai andando pelo vetor, e comparando o que encontra dentro do campo ‘name’ com o cline.cmd (outra estrutura que é alimentada por outra parte do codigo, mas imagine o seguinte: cline.cmd é o comando em questao, add, remove ou qq outro q vc configurou). qd o comando ‘add’ for encontrado ele vai executar a funcao com os argumentos (que foram tratados em outra parte do codigo).

Pronto, codigo limpo, economia de linhas, e facilimo para adcionar ou remover um ou outro comando/funcao. Basta editar o vetor handlers com o nome apropriado da funcao e claro certificarse que a funcao exista no codigo.

Thanks to Froz

1
2

macro index < Esc>w "|formail  -x Subject: -x From: | get_field.py | todo -a -p 4\r"
macro pager  < Esc>w "|formail  -x Subject: -x From: | get_field.py | todo -a -p 4\r"

tem q ter o procmail (pra usar o formail):

1

sudo aptitude install procmail

get_field.py:

1
2
3
4
5
6
7
8

#!/usr/bin/env python
 
import sys
from email.Header import decode_header
 
for f in sys.stdin.readlines():
        field=decode_header(f)
        print field[0][0]

Mas depois de gmail, yahoo mail etc, vc ve que nao precisa realmente de um cliente de email, apenas um browser para acessar o seu webmail.

No meu caso eu centralizo tdo no gmail (baixo tdo das outras contas via pop3, e redireciono as contas @hal.vu para o gmail, fazendo o download das mesmas depois com o fetchmail no server da dreamhost, mantendo um backup de todas as contas de email que existe no gmail, no server da dreamhost). Gosto bastante da interface do gmail (quem nao gosta?) e ainda existem alguns add-ons do ff para usar com ele. Um dos mais legais é o Better Gmail 2.

Para o email do trabalho mesmo (que até tem o webmail , mas é aquele do exchange) eu utilizo o mutt. Sim, o mutt mesmo, aquele ‘em texto’. Alguns dos motivos sao:

-Utilizo as minhas teclas de atalho customizadas ou padrao dele mesmo, posso navegar nas mensagens como navego no vim, ou como quizer.
-Utilizo o proprio vim para editar mensagens.
-Configuro os meus cabecalhos.
-Assino/criptografo mensagens somente com as teclas de atalhos.
-Integracao com o abook.

Entre varias outras… aproveitando só pegar o meu .muttrc.

Mas eu ainda nao tinha um ‘todo manager’.
Foi entao que descobri o devtodo.
Pq usar este cara ?
Novamente, simplicidade.

As vantagens incluem:

-absurdamente facil de adcionar remover ou ler um todo. vc pode por ex. pressionar alt+esc (alt+F2 no gnome) e digitar, todo -a “entrar em contato com o banco para sanar divida”
- salva em xml
-aceita varias (senao todas) operacoes em uma unica linha de comando.
alias acabei de pensar em algumas bindkeys novas para o mutt, como por ex transformar um email em uma entrada ‘todo’… vou la testar.

O site do cara do post anterior é bemmm legal tb.

Achei em um share do google reader, uma url que pode ser util, o Unix ToolBox, com comandos de varios unixes (linux/bsd/solaris) e até de windows, alem de nocoes basicas em linguagens de programacao, utilidades de redes, entre outros. Vale ter no bookmarks.

Me lembro qd era necessario (pra mim, até hoje),  sempre seguir uma receita de bolo para colocar uma distro linux em um pendrive usb (sticky), pois nunca me lembrava como fazer (nao faco tantas vezes assim). Mas pra este caso existe o UNetbootin que faz tdo isso de dentro do windows.