So, how do I use it?

Actually, we will store extra data on another table so, first of all, you need to create this auxiliary table:

CREATE TABLE IF NOT EXISTS `options` (
  `id` int(11) NOT NULL auto_increment,
  `model` varchar(32) NOT NULL,
  `related_id` int(11) NOT NULL,
  `opt_key` varchar(32) NOT NULL,
  `opt_value` text NOT NULL,
  PRIMARY KEY (`id`),
  KEY `opt_key` (`opt_key`)
);

If you can’t have a new table named ‘options’, don’t worry. Just name it something else. Now you need to create the model file for this table. Something like this should be enough:

class Option extends AppModel { }

If you are using a different table name, don’t forget to change the class name to whatever other name you have for it. Now you can download the behavior file here. Place it under your behaviors folder.

Now what?

Let’s pretend that you have a model named Blog which has three columns on it’s table: id, title and content. Generally, if I want to extend this table, I’ll have to deal with it’s schema, but using the Optionable Behavior, things get really easy. Imagine that I want to add my mood and the current weather to some posts on the blog. I just have to do something like this:

public $actsAs = array(
	'Optionable' => array(
		'model' => 'Option',
		'fields' => array('mood', 'weather'),
		'emptyFields' => true
	)
);

Now I can just put those extra keys on a form, save some data and that is it. The data will be retrieved from the database just like if they were from the Blog’s schema itself.

See that we have three configuration keys to the behavior:

• model: defaults to ‘Option’. Just define this if you are using a different table name.
• fields: no default. Here you can define every optional field that you want to use in your model.
• emptyFields: defaults to true. If true, even if that option is not registered on the auxiliary table, the key will be present on the data array.

This behavior tries it’s best to make every optional field feels like a native one. This means that you can save, validate and retrieve optional data just like you would with common fields. We are working to make it possible to filter data by optional fields as well.

A great benefit of using this behavior is that you can store different data types on the DB seamlessly. Every data is serialized before getting saved to the table. That means that you can store arrays, objects and other data types not natively supported by RDBMSs without having any trouble converting them as they come and go.

Well, I guess this is it. If you have any idea on how to make this work any better, please, share with us! Here is the code:

So I decided to create a brand new theme. I started to design it yesterday and it done already [or mostly]. As you can see, it’s a very simple theme. Actually, I’m only using the “index.php” file of the theme and nothing else. I know I’m missing a lot of things, but I plan to add those as we go.

I’ve tried to create a very simple theme, with the basics to deliver messages, articles and codes I’ve been creating. The typeface I’m using is called Inconsolata and it is the very same typeface I use on my code editor, so it reflects my new passion in life.

I’m also using DISQUS for comments. I can’t tell how much I hated to create all those comments stuff on WP themes, so using that was a great *great* relieve. I’ve removed a lot of old and outdated posts or posts I didn’t consider relevant anymore so the blog is really empty right now. Hopefully, I’ll start to blog more and more about consistent things.

And finally, I’ll try to blog in english from now on, so expect a lot of grammar errors and wrong spelling! I’ve added an authomatic link to translate posts with Google Transaltor so I hope no one misses anything!

I guess that is all. Maybe I’ll post some new things later, maybe not so, subcribe to the RSS and you won’t even have to see which theme I’m using!

Here is a simple function that helps me to sort elements in a MySQL database by it’s ID’s:

If that is usefull to you, let me know!

This is particularly useful to create SEO links out of, for example, a table of articles. Instead of seeing those ugly /articles/view/4 URLs, use the Sluggable Behavior and easily accept URLs such as /articles/view/my-seo-friendly-article. It handles the slug creation, slug collision, and allows you to specify different settings such as the separator to use, maximum width of a slug, among other useful parameters.

My Sluggable Behavior is a simpler version of Mariano Iglesias’ Sluggable Behavior with a few add-ons. It’s basically the same thing but instead of implementing all the slug logic on the behavior, it just uses Cake’s Inflector::slug() method. With CakePHP 1.3, this method is really powerful and flexible.

To use it, just place the behavior file on the proper place and call it on the model you want to “slugify”:

var $actsAs = array('Sluggable');

By default, this will automatically create slugs from a field named “title” and place it under a field named “slug”. If you want, you can customize everything. Checkout the configuration keys:

var $actsAs = array(
	'Sluggable' => array(
		'fields' => 'title',
		'scope' => false,
		'conditions' => false,
		'slugfield' => 'slug',
		'separator' => '-',
		'overwrite' => false,
		'length' => 256,
		'lower' => true
	)
);

Those are all the default values. Let’s check what they can do, one by one:

• fields: as you can see, this is where you define which field will provide the content to the slug. You can inform more than one with an array.
• scope: after generating a slug, the system will check for similar slugs on the database in order to generate a unique slug. By default, it will scan all your registries, but you can define scopes. Example: you want the system to use an already registered slug on a different category. You can define an array like this: ‘scope’ => array(‘category_id’). The system will only check for records where the “category_id” is the same from the data being saved.
• conditions: these are extra conditions you can inform. The system will scan for similar slugs previously registered on the database using those conditions as well. They work just like a normal find conditions array.
• slugfield: the name of the field that will store the slug on the database.
• separator: the character that will be used to replace white spaces on the slug.
• overwrite: if true, this will replace the slug from a record on update, otherwise it will be kept untouched on a update.
• length: this defines the length of the slug text.
• lower: if false, the behavior won’t make the slug all lower case.

Once again, this behavior is totally inspired by Mariano Iglesias’ Sluggable Behaviour. If you want to help, please comment! Here is the source code:

Na verdade, na época a coisa já havia mudado, mas eu não sabia. Foi quando eu encontrei este outro artigo aqui. O artigo ensina como fazer joins em casos específicos utilizando o Model::find().

Então imagine que temos duas tabelas, uma de Posts e outra de Tags e exista uma relação HABTM entre elas. Eu quero encontrar todos os posts com a Tag “design”, como fazer?

Uma vez dentro do controller dos posts eu posso escrever o seguinte código:

Obs.: Este código não foi testado e seu objetivo é apenas o de ilustrar as possibilidades aqui apresentadas.

$posts = $this->Post->find('all', array(
	'joins' => array(
		array(
			'table'      => 'posts_tags',
			'alias'      => 'PostsTag',
			'type'       => 'INNER',
			'conditions' => array('PostsTag.post_id = Post.id')
		),
		array(
			'table'      => 'tags',
			'alias'      => 'Tag',
			'type'       => 'INNER',
			'conditions' => array(
				'Tag.id = PostsTag.tag_id',
				'Tag.tag LIKE' => '%design%'
			)
		)
	)
));

Trazendo um caso da vida real, na Quitanda eu queria mostrar os últimos posts de uma determinada categoria dentro do painel dos usuários com lojas. O nosso blog é feito com WordPress. Eu teria que criar um arquivo model para a tabela de posts do WP para poder fazer isso, mas fiquei com preguiça já que este seria o único lugar onde isto aconteceria, então ao invés de criar um arquivo de modelo, eu criei ele dentro do próprio controller utilizando a classe ClassRegistry e o método init.

Como minha tabela do WordPress era diferente da utilizada pela aplicação, primeiro eu defini um novo vetor de configurações no meu arquivo config/database.php. Veja:

var $wp = array(
	'driver' => 'mysql',
	'persistent' => false,
	'host' => 'localhost',
	'login' => 'user',
	'password' => 'password',
	'database' => 'qolwp',
	'encoding' => 'utf8'
);

Depois, já no meu controller, escrevi a seguinte linha:

$this->WpPost = ClassRegistry::init(array(
	'ds' => 'wp',
	'table' => 'wp_posts',
	'class' => 'model',
	'alias' => 'WpPost'
));

Os parâmetros praticamente se auto explicam mas, a chave ‘ds’ guarda a variável de configuração do banco que vai ser utilizada, no caso ‘wp’, como definido anteriormente. Depois dizemos qual é a tabela a ser utilizada, o tipo de classe a ser registrada e o ‘alias’ para ser utilizado nas consultas.

Depois eu fiz a consulta. Ela ficou meio extensa e é claro que escrevendo isto direto no SQL seria muito mais simples, mas fica aqui a titulo de exemplo. Eu fiz isso mais para experimentar as possibilidades e ver o que acontecia. Olha só:

$posts = $this->WpPost->find('all', array(
        'joins' => array(
                array(
                        'table' => 'wp_term_relationships',
                        'alias' => 'WpTermRelationship',
                        'type' => 'INNER',
                        'conditions' => array('WpPost.ID = WpTermRelationship.object_id')
                ),
                array(
                        'table' => 'wp_term_taxonomy',
                        'alias' => 'WpTermTaxonomy',
                        'type' => 'INNER',
                        'conditions' => array('WpTermRelationship.term_taxonomy_id = WpTermTaxonomy.term_taxonomy_id')
                ),
                array(
                        'table' => 'wp_terms',
                        'alias' => 'WpTerm',
                        'type' => 'INNER',
                        'conditions' => array('WpTermTaxonomy.term_id = WpTerm.term_id')
                )
        ),
        'conditions' => array(
                'WpPost.post_type' => 'post',
                'WpPost.post_status' => 'publish',
                'WpTermTaxonomy.taxonomy' => 'category',
                'WpTerm.slug' => 'painel'
        ),
        'fields' => array(
                'WpPost.post_title',
                'WpPost.post_content',
                'WpPost.guid',
                'WpPost.post_date'
        ),
        'group' => 'WpPost.ID',
        'order' => 'WpPost.post_date DESC',
        'limit' => 5
));

O SQL que esta função vai criar fica assim:

SELECT `WpPost`.`post_title`, `WpPost`.`post_content`, `WpPost`.`guid`, `WpPost`.`post_date` FROM `wp_posts` AS `WpPost` INNER JOIN wp_term_relationships AS `WpTermRelationship` ON (`WpPost`.`ID` = `WpTermRelationship`.`object_id`) INNER JOIN wp_term_taxonomy AS `WpTermTaxonomy` ON (`WpTermRelationship`.`term_taxonomy_id` = `WpTermTaxonomy`.`term_taxonomy_id`) INNER JOIN wp_terms AS `WpTerm` ON (`WpTermTaxonomy`.`term_id` = `WpTerm`.`term_id`) WHERE `WpPost`.`post_type` = 'post' AND `WpPost`.`post_status` = 'publish' AND `WpTermTaxonomy`.`taxonomy` = 'category' AND `WpTerm`.`slug` = 'painel' GROUP BY `WpPost`.`ID` ORDER BY `WpPost`.`post_date` DESC LIMIT 5

Com isto você já pode ver que existem muitas possibilidades. Por exemplo, você pode fazer consultas com LEFT JOIN ao invés de INNER JOIN simplesmente trocando a chave ‘type’. Veja também que nas condições gerais da minha consulta eu pude colocar filtros diretamente relacionados às tabelas que eu dei join. No artigo original existe uma chave ‘foreignKey’ com valor false, mas analisando a API, não achei nenhuma referência a este valor em nenhum dos adaptadores de bancos de dados, então me parece ser algo totalmente dispensavel e a função funciona sem que ela seja declarada.

Um tempo depois criamos vergonha na cara e resolvemos utilizar uma plataforma de e-commerce de verdade para montar nossa lojinha. Utilizamos o osCommerce naquela época, foi uma revolução pra gente! Tudo estava funcionando de um jeito bem legal mas acho que por falta de tempo ou qualquer coisa assim, a loja acabou não indo mais pra frente. O site morreu, mas o Gustaf ainda fazia o esquema de trazer cd’s de fora pra galera aqui. Foi aí que surgiu a idéia, a semente do que viria ser a Quitanda On-Line que chega à existência no dia de hoje! Pra mim é um sonho realizado, algo que eu idealizei a bem uns 4 ou 5 anos atras.

A Quitanda pretende ser um site onde qualquer pessoa possa criar uma pequena loja virtual com tudo o que é necessário para realizar transações pela internet, com controle de estoque, imagens, lista de clientes e tudo mais. Cada lojista é independente e tem seu próprio cantinho, podendo personalizar sua loja e tudo mais. E adivinha. O SofaNews já está por lá

Eu estou muito feliz e espero que este projeto possa render muitos frutos. No mínimo, tem sido muito legal e proveitoso trabalhar neste projeto. Um grande aprendizado!

Na parte técnica, estamos rodando o site na SliceHost num slice de 256Mb de RAM, 10Gb de espaço e 100Gb de banda (espero que esta configuração precise ser mudada em breve). O servidor que escolhemos foi o lighttpd rodando php em fast-cgi. Estamos trabalhando o cache com APC por enquanto, e tem sido muito bom! Também estamos utilizando o Amazon S3 para guardar as imagens, o que reduz bastante o impacto no nosso servidor.

[edit]
Em tempo, o Edu Duccigne escreveu um post super legal sobre a gente no blog dele! Veja aqui!
[/edit]

Eu queria agradecer muito à minha namorada que sempre acreditou em mim e neste meu sonho. Ela é maluca de ficar comigo nesse pensamento louco. Sem ela, acho que não conseguiria! Também queria agradecer a Natália que comprou a idéia e mergulhou de cabeça junto comigo nessa empreitada! Seu toque feminino é muito importante neste projeto! Também queria agradecer ao meu pai, à minha mãe, que sempre me estimularam a seguir os meus sonhos sem desistir e me ensinaram que sem trabalho não se vai a lugar algum. Queria agradecer muito ao Rafa pelo nome genial que ele escolheu pra gente E por fim, mas não menos importante, meus agradecimentos ao Gustaf, papy Helmuth e mamy Shirley, por todo o apoio!

E agora vamo que vamo

FalaFreela vai ao ar toda segunda-feira (eu acho) e conta com a participação do Mauro Amaral (aqui e aqui) Humberto Oliveira (aqui) e Carol Vigna-Maru (aqui e aqui). Se eu fosse você, assinava o feed e ouvia toda semana

Foi uma longa jornada pra poder conciliar meu trabalho diário com horas extras pra terminar o tu-dus. Na verdade, eu só fiz o tu-dus pra poder conciliar melhor as coisas na minha vida.

tu-dus é um aplicativo on-line que te permite organizar suas tarefas e eu vou explicar o “por quê” de eu ter criado esse treco.

Depois de ler muito sobre produtividade, sobre como vencer a procrastinação, aprendido um pouco de GTD e experimentado muitos aplicativos para estes fins, percebi que, pra mim, uma folha de papel ou um arquivo de texto eram muito mais eficientes do que alguns estes programas [eu ainda sou fã do Post Task] na hora de organizar minhas tarefas. O problema não eram os programas em si. Todos eles são muito bons, com características muito bacanas mas, enquanto uns tinham opções de mais, outros não tinham aquelas opções legais que eu gostaria de ter à mão pra aplicar de uma forma bem eficaz os conceitos e processos de produtividade que eu havia aprendido. Ainda assim eu gostaria de ter alguma ferramenta que fosse mais fácil de usar que um bloco de notas, sem ter que ficar digitando e identando minhas tarefas, foi então que surgiu a idéia de fazer o tu-dus. Ele é um aplicativo que fiz pra suprir minhas próprias necessidades de organização e espero que outras pessoas possam se identificar com o ele.

E o que ele tem de diferente?

Bem, o tu-dus é um aplicativo muito simples. Basicamente, ele é um app pra guardar suas tarefas e notas [caso você precise colocar um texto maior pra consultas e etc]. O grande barato é que ele funciona mais ou menos como as pastas de um sistema operacional. Dentro de cada ítem da sua lista, você pode criar uma nova lista com outros itens e notas e assim infinitamente.

Por que isso?

Esta característica, apesar de simples, é muito poderosa, pois expande a abrangência do tu-dus pra além de suas tarefas. Ele é uma ferramenta que te permite criar listas sobre qualquer coisa sem que tudo vire uma banguça, deixando as informações sempre à mão pra quando for necessário. Ele também facilita a aplicação dos principais conceitos de produtividade espalhados por aí.

Você vai perceber que não existe nada no tu-dus além de ferramentas pra adicionar itens e notas. A gente fez o tu-dus da forma mais simples possível pra que ele seja também o mais flexível. Algumas características que seriam facilmente encontradas na maioria dos “task managers” como agendamentos, prioridades e etc., você não vai encontrar no tu-dus, isto porque a idéia é que você organize suas tarefas da maneira que achar melhor e não da maneira que nós permitimos. Pelo fato de ser possivel criar listas dentro de listas, fica fácil criar um item para um determinado dia, ou organizar suas tarefas dentro de um item que determina uma certa prioridade e assim por diante…

E como você fez isso?

Bom, eu não sou nenhum expert em programação. Como sempre digo, sou um eterno noob neste mundo, mas ando dando os meus pitacos. Então desde que aprendi a usar CakePHP, tenho podido pensar além das minhas limitações como programador, visto que o framework me ajuda bastante na hora de realizar tarefas que, sozinho, eu penaria muito pra fazer. Foi com ele que eu criei a parte server-side do tu-dus.

Para a parte client-side eu usei o charmoso jQuery. Ele me ajudou muito na hora de criar um código limpo, sem eventos no meio do HTML nem nada. Suas capacidades de seleção são muito poderosas e bacanas. Aposto que existem outros frameworks de JS tão legais quanto (estou de olho no Dojo) mas o jQuey respondeu muito bem às minhas expectativas e foi ótimo aprender a utilizá-lo.

Bom, é isso! Se você leu este artigo e quer experimentar o tu-dus, fique à vontade! Ele é totalmente gratuito, o cadastro demora menos de 30 segundos e é só alegria. Espero que gostem e qualquer coisa, mande um comentário aí com sugestão ou pergunta ou crítica, ou mande email pra contato@tu-dus.com.

Ele tem este nome porque diz ser um “Fórum Crucial”, ou seja, só possui aquilo que é extremamente básico pra um fórum funcionar. No caso do CruciForum isto quer dizer que qualquer um pode adicionar e responder tópicos livremente, sem cadastros chatos nem nada! Imagine que o CruciForum é como se fosse um blog muito básico, onde qualquer um coloca seus posts e qualquer outra pessoa pode comentar!

E apesar desta idéia parecer estranha numa época em que spams são vastamente propagados por aí, o CruciForum tem suporte ao sistema Askimet de prevenção contra spams! Quem usa WordPress já conhece o Askimet. É um software desenvolvido pela mesma empresa criadora do WordPress que reconhece e marca mensagens que sejam spams. Deste jeito, ninguém vai poder adicionar conteúdos duvidosos no seu fórum.

Outra grande característica do CruciForum e que acabou me levando a um outro grande sistema on-line foi a utilização do sistema Gravatars para exibir imagens dos autores. Gravatars é um acrônimo para “Globally Recognized Avatars” ou “Avatares Globalmente Reconhecidos”. É um site onde você pode anexar seu email a diferentes imagens, que podem ser resgatadas por sites que utilizam códigos especiais pra reconhecer estas imagens simplismente pela informação do seu endereço de email, ou seja, você não precisa de nenhum registro para colocar um avatar bonito de até 80×80 pixels nos posts do seu fórum.

A instalação do fórum é a coisa mais ridícula do mundo e um dos motivos pra isto é que ele não utiliza nenhum banco de dados. Você baixa um único arquivo php, executa ele no servidor, numa pasta com CHMOD 777 e pronto! Ele gera uma série de arquivos e o fórum já está pronto pra rodar. Aí vão uns screenshots:

1. Tela da primeira vez que o script é executado…
   
2. Tela seguinte, logo após a instalação estar completa e o fórum pronto pra uso…
3. Tela principal do fórum, com a listagem de posts…
4. Onde acontece o envio dos posts!

Os arquivos gerados são muito simples, então fica fácil criar um tema personalizado, adiconar funções javascript, um css diferenciado e tudo mais, enfim, ele é totalmente extensível, “o fórum dos sonhos”! Claro que não vai servir pra qualquer tipo de site, mas no geral, acho que é totalmente suficiente e eficaz.

Você pode ver um “demo” do fórum aqui! Muito fácil de usar. Ainda existem algumas pendências como a ineficiência do cookie que guarda suas informações pessoais [pra evitar você de ter que digitar os mesmos dados sempre], mas Stuart Langridge, criador do CruciForum e figurinha carimbada do mundo do desenvolvimento pra web, parece estar sempre mexendo aqui e ali no sistema, então novas versões aprimoradas estão sempre aparecendo por aí. Nota 10 [apesar dos bugzinhos]!

Eber, you are somewhat left-hemisphere dominant and show a preference for visual learning, although not extreme in either characteristic. You probably tend to do most things in moderation, but not always.

Your left-hemisphere dominance implies that your learning style is organized and structured, detail oriented and logical. Your visual preference, though, has you seeking stimulation and multiple data. Such an outlook can overwhelm structure and logic and create an almost continuous state of uncertainty and agitation. You may well suffer a feeling of continually trying to “catch up” with yourself.

Your tendency to be organized and logical and attend to details is reasonably well-established which should afford you success regardless of your chosen field of endeavor. You can “size up” situations and take in information rapidly. However, you must then subject that data to being classified and organized which causes you to “lose touch” with the immediacy of the problem.

Your logical and methodical nature hamper you in this regard though in the long run it may work to your advantage since you “learn from experience” and can go through the process more rapidly on subsequent occasions.

You remain predominantly functional in your orientation and practical. Abstraction and theory are secondary to application. In keeping with this, you focus on details until they manifest themselves in a unique pattern and only then work with the “larger whole.”

With regards to your career choices, you have a mentality that would be good as a scientist, coach, athlete, design consultant, or an engineering technician. You can “see where you want to go” and even be able to “tell yourself,” but find that you are “fighting yourself” at the darndest times.

As porcentagens foram as seguintes:

Auditory : 27%
Visual : 72%
Left : 68%
Right : 31%