Blog Patrick Espake

No plugin Paperclip existem dois callbacks que podem ser usados no model.

O primeiro é o before_column_post_process usado antes de salvar e o segundo after_column_post_process usado depois de salvar.

Onde aparece column troque pelo nome da sua coluna do anexo.

Por exemplo, a minha coluna se chama file, logo os nomes dos métodos ficam before_file_post_process e after_file_post_process:

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

class Image < ActiveRecord::Base
  has_attached_file :file,
                    :styles => {:large => '600x600>', :medium => '300x300>', :small => '150x150>', :thumb => '50x50>'},
                    :path => ":rails_root/public/images/:id/:style_:basename.:extension",
                    :url => "/images/:id/:style_:basename.:extension"
  validates_attachment_presence :file
  validates_attachment_content_type :file, :content_type => ['image/jpeg', 'image/png', 'image/gif']
  before_file_post_process :post_before_process_file
  after_file_post_process :post_after_process_file
 
  def post_before_process_file
    raise "Executado antes de salvar"
  end
 
  def post_after_process_file
    raise "Executado depois de salvar"
  end
end

Você pode usar esses callbacks para fazer algum tratamento adicional nos anexos.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Ontem teve um seminário em Curitiba/PR sobre desenvolvimento para o iPhone, alguns conhecidos foram e nós iniciamos uma discussão sobre o assunto no grupo CuritibaDev (http://groups.google.com/group/curitibadev).

A minha opinião sobre o assunto é a seguinte:

• O lance da falta de documentação e as limitações da difusão do conhecimento sobre o iPhone que são as grandes limitações dessa tecnologia.
• Particularmente eu não me sinto animado em programar para o iPhone por essas características da Apple, com certeza são táticas para defender mercados. No momento pra mim o iPhone e os produtos da Apple fazem parte da AppleMania, todo mundo quer ter por que é moda e dá status social com eles, só uma forma de fazer o ser humano se sentir bem através dos seus brinquedos.
• Eu acho que o mercado para symbian, python, java me, android e flash são fortes, os caras que manjam dessas tecnologias só falam mal do iPhone nos blogs por ae.
• Tem um lance que não tem como falar mal da Apple, as piras que touch que eles criaram são muito legais e o sensores presentes no iPhone e iPod Touch de movimento são muito fodas, o foda que eles patentearam todas essas piras touch.
• É a Apple está muito longe de ser uma empresa de software livre, por enquanto eu vou continuar usando e abusando do software livre. ;-)

Contribua deixe sua opinião nos comentários.

Se caso você precise usar rotas dentro do Model por algum motivo, aqui vai a dica, faça o include ActionController::UrlWriter no seu Model. Isso vai deixar disponível os métodos de geração de urls.

Por exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class NodeType < ActiveRecord::Base
  include ActionController::UrlWriter
 
  # ações realizadas após criar
  after_create :create_backend_menu
 
  # ações realizadas após apagar
  before_destroy :destroy_backend_menu
 
  # cria o menu para o conteúdo
  def create_backend_menu
    root = BackendMenu.find_by_path('admin_create_content_index_path')
 
    path = new_admin_node_type_node_path(self)
    root.children.create(:title => self.name,
      :path => path,
      :weight => 1,
      :is_active => true,
      :description => self.description)
  end
 
  # apaga o menu para o conteúdo
  def destroy_backend_menu
    path = new_admin_node_type_node_path(self)
    menu = BackendMenu.find_by_path(path)
    menu.destroy
  end
end

Até mais!

Se você gostou desse texto e acha que ajudou você, me recomende: .

No Ruby on Rails é possível fazer um model trabalhar em árvore, isso é algo muito interessante quando você precisa trabalhar com categorias e subcategorias. Essa árvore não tem limite de crescimento, você pode ter várias subcategorias dentro de subcategorias.

Esse comportamento de árvore do model recebe o nome de acts_as_tree.

No Ruby on Rails 1.2 o acts_as_tree fazia parte do ActiveRecord, no Ruby on Rails 2 ele não faz mais parte, para usar você precisa instalar o plugin acts_as_tree.

Instalação:

1

ruby script/plugin install acts_as_tree

Configuração:

É necessário ter mais uma coluna na tabela chamada parent_id através dessa coluna é possível estabelecer a relação entre pais e filhos, ou seja, categoria e subcategorias.

Por exemplo:

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

class CreateBackendMenus < ActiveRecord::Migration
  def self.up
    create_table :backend_menus do |t|
      t.string  :title,     :null => false
      t.string  :path,      :null => false
      t.integer :weight,    :null => false, :default => 0
      t.boolean :is_active, :null => false, :default => false
      t.integer :parent_id
      t.timestamps
    end
  end
 
  def self.down
    drop_table :backend_menus
  end
end

Agora no model você deve adicionar o comportamento de árvore acts_as_tree e especificar uma coluna para ordenação:

1
2
3
4

class BackendMenu < ActiveRecord::Base
  # comportamento de árvore
  acts_as_tree :order => 'weight'
end

Desta forma serão criados alguns métodos para você conseguir trabalhar com a árvore:

Representação do Model com Acts as Tree

1
2
3
4
5
6
7
8

root      = Category.create("name" => "root")
child1    = root.children.create("name" => "child1")
subchild1 = child1.children.create("name" => "subchild1")
 
root.parent   # => nil
child1.parent # => root
root.children # => [child1]
root.children.first.children.first # => subchild1

Existe mais 4 métodos que podem ser úteis:

• ancestors: Retorna lista dos antepassados, a partir da mãe até raiz;
• root: Retorna o nó raiz da árvore;
• siblings: Retorna todos os irmãos do nó atual;
• self_and_siblings: Retorna todos os irmãos e uma referência ao nó atual.

Se você gostou desse texto e acha que ajudou você, me recomende: .

A partir da versão 2.2 do Ruby on Rails existe o plugin TranslateRoutes (http://github.com/raul/translate_routes/tree/master), esse plugin tem o objetivo de traduzir as suas rotas para vários idiomas.

Instalação:

1

ruby script/plugin install git://github.com/raul/translate_routes.git

Configuração:

No diretório config/locales crie um arquivo chamado i18n-routes.yml, nesse arquivo ficarão as traduções das urls:

1
2
3
4
5

pt-BR:
  new: "novo"
  edit: "editar"
  show: "exibir"
  users: "usuarios"

Esse plugin consegue trabalhar com rotas RESTFul e rotas padrões, desta forma você pode traduzir os paths como new, edit, show e users que representam uma rota RESTFul.

Agora é necessário habilitar o sistema de rotas para trabalhar com I18n, edite o arquivo routes.rb e adicionei a seguinte linha ActionController::Routing::Translator.i18n no final:

1
2
3
4
5
6
7
8

ActionController::Routing::Routes.draw do |map|
  map.resources :users
 
  map.connect ':controller/:action/:id'
  map.connect ':controller/:action/:id.:format'
end
 
ActionController::Routing::Translator.i18n

Para mais informações: http://github.com/raul/translate_routes/tree/master.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Eu estou usando Rails Engines em um projeto grande que eu estou desenvolvendo e esse projeto precisa trabalhar com I18n.

Por padrão no Rails no diretório config/locales ficam as traduções, o problema que usando Rails Engines as aplicações embutidas ficam como plugin no diretório vendor/plugins/meu_plugin.

Eu quero deixar as traduções I18n bem divididas e cada Rails Engine tem que ter o seu próprio arquivo de tradução, isso vai facilitar a minha vida para gerenciar a aplicação.

Para resolver esse problema na Rails Engine eu criei o diretório config/locales também, ficando o caminho completo /vendor/plugins/meu_plugin/config/locales e dentro desse diretório eu criei o arquivo pt-BR.yml somente com as traduções que interessam para essa aplicação embutida:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

pt-BR:
  # Active Record
  activerecord:
    attributes:
      meu_model:
        kind: "Tipo"
        name: "Nome"
        module: "Módulo"
        description: "Descrição"
        help: "Ajuda"
        title_label: "Título"
        body_label: "Conteúdo"
        has_body: "Tem conteúdo"
        published: "Publicado"
        promoted_to_front_page: "Promover na página inicial"

Agora eu preciso fazer o Rails pegar essa tradução e usar no escopo da aplicação, para fazer isso eu adicionei a linha abaixo no arquivo vendor/plugins/meu_plugin/init.rb:

1
2

# Include hook code here
I18n.load_path += Dir[Rails.root.join('vendor', 'plugins', 'meu_plugin', 'config', 'locales', '*.{rb,yml}')]

Agora quando o Rails carregar o plugin vai carregar também o arquivo de tradução da Rails Engine.

Obs.: Eu acho que o Rails já deveria carregar por padrão todos os arquivos de I18n dentro dos plugins, mas ele não faz isso no momento, eu achei um patch para o Rails que tem o objetivo de adicionar essa funcionalidade: https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2325-i18n-support-for-engines.

Se você gostou desse texto e acha que ajudou você, me recomende: .

Essa semana eu entreguei um sistema de gerenciamento de torneios de futebol, eu já tinha feito esse sistema há um tempo atrás em PHP, mas percebi que estava muito enrolado para dar manunteção no código então resolvi refazer ele do zero em Ruby on Rails 2.2.2, aproveitei também para fazer diversas melhorias e implementar novos conceitos.

Esse sistema está disponível em http://campeonatos.centroirai.com.br, ele é um sistema universal de gerenciamento de torneios de futebol, ou seja, é possível colocar nele vários formatos diferentes de torneios de futebol e o sistema consegue gerenciar todo o conteúdo.

O sistema é composto de duas áreas, a primeira é a área de visualização do visitantes http://campeonatos.centroirai.com.br a segunda é a área administrativa http://campeonatos.centroirai.com.br/admin, através da área administrativa é possível administrar todos as informações que compõem um determinado torneio.

Área Administrativa

O sistema trabalha em cima de torneios, desta forma o principal conteúdo é o torneio e todos os demais conteúdos estão relacionados com o torneio.

No gerenciamento do torneio é possível definir se ele está ativo, uma imagem para ilustrar, data de início, data de término, também é possível definir se o torneio está aberto para receber pré-inscrições de jogadores, essa opção permite que as pessoas interessadas possam fazer a sua pré-inscrição para participar do torneio.

Cadastro de Torneio

A grande parte dos conteúdos do sistema aceitam descrição, para os campos de descrição foi usado o MCE Editor, desta forma é possível dar uma maior flexibilidade para o usuário alimentar o conteúdo do sistema.

Através da área administrativa é possível gerenciar os jogadores, gerenciar as equipes, fazer a associação entre jogadores e equipes, definir as etapas do torneio, os grupos dentro de cada etapa, gerenciar os jogos (definindo o confronto, data e hora), gerenciamento de placares dos jogos, gerenciamento de empresas que apoiam o torneio, gerenciamento de álbum de fotos, gerenciamento de vídeos com upload no formato flv e conteúdo do YouTube. O sistema também proporciona a criação de banners no topo, rodapé e menu lateral para cada torneio, desta forma é possível ter patrocinadores específicos para cada torneio. Todas as pré-inscrições recebidas também podem ser gerenciadas através da área administrativa, bem como o regulamento do torneio, que aceita descrição ou upload de um arquivo PDF com o regulamento.

Associação de jogadores x equipes

Tanto as etapas como os grupos podem ser ordenados através de drag e drop, esse ordenamento é levando em consideração na exibição dos jogos e classificações na área de visualização dos visitantes.

Ordenação de etapas drag e drop

Cadastro de jogo

Na definição do placar e possível definir a quantidade de gols que cada jogador de cada time vez, desta forma o sistema consegue obter a artilharia do torneio.

Cadastro de placar

O sistema aceita N álbuns de fotos, e N fotos relacionadas com o álbum, os formatos de imagens aceitos são jpg, gif ou png. Todos os conteúdos que tem imagens trabalham com lightbox para exibição das imagens e navegação entre próxima e anterior.

Lightbox para as imagens

Para agregar mais informação e interesse no sistema foi adicionado a parte de vídeos, onde e possível fazer upload de arquivos FLV ou vincular o conteúdo com o YouTube.

Vídeos do YouTube

Vídeo FLV

Já na área de visualização pelos visitantes existe a funcionalidade acompanhar o desempenho da equipe, ver os próximos jogos, classificação no torneio, os jogadores que fazem parte de cada equipe, regulamento, artilharia, fotos, vídeos, empresas que apoiam o torneio e banners de patrocionadores no topo, rodapé e menu lateral.

Página da equipe

Classificações do torneio

Jogos do torneio

Artilharia do torneio

Álbuns de fotos

Vídeos

Para construir esse projeto em Ruby on Rails eu usei as gems: fastercsv (para exportar os contatos dos jogadores para csv), will_paginate, paperclip e os plugins: activerecord_i18n_defaults e lightbox.

Nos últimos meses estou trabalhando numa porção de projetos interessantes, estou aproveitando também para colocar em prática algumas ideias que já tinha pensado há muito tempo atrás.

Realmente a vida é uma grande correria, mas sabendo levar é possível fazer o tempo render bastante e conseguir deixar tudo encaminhado.

Bom enquanto não consigo realizar o primeiro sonho, que é morar na praia de frente para o mar e trabalhar remotamente, eu vou tocando a vida na cidade grande com todo o seu stress cotidiano, e capitalismo sanguinário.

Finalmente eu parei uns 10 minutos e criei uma página quebra galho para o meu site pessoal http://www.patrickespake.com/, é algo provisório. A longo prazo tenho muitos planos para ele.

Por enquanto vou focar mais a minha atenção para o Lab Patrick Espake, http://lab.patrickespake.com/, aqui sim eu vou explorar mais a curto prazo, pretendo disponibilizar várias teorias, técnicas e algoritmos que ando inventando.

Por hoje chega!

Felicidades a todos.