Posts Tagged ‘activerecord’

Ruby on Rails Validação de Data

Postado em 05 nov 2009
Categoria(s) Ruby on Rails

Não existe no core do Ruby on Rails um validator para datas, mas existe um plugin que faz muito bem essa tarefa, o nome do plugin é validates_date_time.

Esse plugin está disponível no Github em: http://github.com/nickstenning/validates_date_time/.

Instalação

./script/plugin install git://github.com/nickstenning/validates_date_time.git

Configuração

class Investor < ActiveRecord::Base
  validates_date :date_of_birth
end

Esse validator aceita datas no formato: 2006-01-01 ou 1 Jan 06 ou 1 Jan 2006 ou 10/1/06 ou 1/1/2006, por padrão o plugin espera datas no formato dia/mês/ano, caso você queria datas no formato americano e necessário adicionar a seguinte linha no seu config/environment.rb:

ValidatesDateTime.us_date_format = true

Outro detalhe é que o validates_date por padrão considera que o campo de data é obrigatório, caso você queria que seu preenchimento seja opcional você pode adicionar o parâmetro :allow_nil => true da seguinte forma:

validates_date :date_of_birth, :allow_nil => true

I18n

Eu procurei na internet uma forma elegante para usar I18n no plugin, eu encontrei apenas uma (http://github.com/nickstenning/validates_date_time/blob/master/test/fixtures/en.yml), mas essa solução não contempla todas as mensagens de validações, existe a mensagem de validação de data inválida que eu não consegui traduzir da forma do link anterior, desta forma eu implementei manualmente o I18n para a mensagem de validação “is an invalid date” da seguinte forma:

No arquivo config/locales/pt-BR.yml adicionei o atributo invalid_date:

pt-BR:
  # Active Record
  activerecord:
    errors:
      messages:
        invalid_date: "é uma data inválida"

e no model eu configurei da seguinte forma:

class Investor < ActiveRecord::Base
  validates_date :date_of_birth, :message => I18n.t('activerecord.errors.messages.invalid_date')
end

O plugin também trabalha com validações time e date time, nos formatos: 1pm ou 10:11 ou 12:30pm ou 8am e 1 Jan 2006 2pm ou 31/1/06 8:30am.

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

  • Share/Bookmark

Ruby on Rails plugin tableless_model

Postado em 11 ago 2009
Categoria(s) Plugins, Ruby on Rails

tableless_model

Ruby on Rails model sem banco de dados, com todo o poder do ActiveRecord e validações.

A principal utilidade é usar em formulários que não precisam de banco de dados, mas precisam das validações do ActiveRecord, form_for e rotas RESTful. Por exemplo formulário de contato.

Instalação

./script/plugin install git://github.com/patrickespake/tableless_model.git

Geradores

Gerador tableless_model

Cria o esboço de um novo tableless model. Passe o nome do tableless model, em CamelCased ou under_scored, e uma lista de pares de atributos opcionais como argumentos.

Os atributos pares opcionais são column_name:sql_type como argumentos, especificando os atributos do tableless model.

Você não tem que pensar em cada atributos lá na frente, mas ajuda a esboçar um pouco para que você possa começar a trabalhar com o tableless model imediatamente.

Isto gera uma classe tableless model em app/models, um teste de unidade em test/unit e uma fixture em test/fixtures/singular_name.yml

Exemplos:

./script/generate tableless_model contact

Cria o tableless model Contact, test e fixture:

  • Model: app/models/contact.rb
  • Test: test/unit/contact_test.rb
  • Fixtures: test/fixtures/contacts.yml
./script/generate tableless_model invite name:string body:text email:string

Cria o tableless model Invite com a string name, text body e string email.

Gerador tableless_scaffold

Tableless scaffolds é composto por vários recursos, a partir do model, controller e views, juntamente com um conjunto completo de testes. O recurso está pronto para ser usado como um ponto de partida, sendo RESTful, orientado para o pedido.

Passe o nome do tableless model (na forma singular), em CamelCased ou under_scored, como primeiro argumento, e uma lista de pares de atributos opcionais.

Os pares de atributos opcionais são column_name:sql_type, especificando os atributos do modelo.

Você não tem que pensar em cada atributo lá na frente, mas ajuda esboçar um pouco para que você possa começar a trabalhar com os recursos imediatamente.

Por exemplo ‘tableless_scaffold contact name:string telephone:string firm:string email:string message:text’ dá-lhe um tableless model com cinco atributos, um controlador para lidar com a criação, formulário para criar os contatos e routas declaradas em config/routes.rb.

Se você quiser remover todos os arquivos gerados, execute:

script/destroy scaffold ModelName

Exemplos:

./script/generate tableless_scaffold invite
./script/generate tableless_scaffold contact name:string telephone:string firm:string email:string message:text

Tipos de colunas disponíveis nos tableless_models

1
2
3
4
5
6
7
class ModelName < TablelessModel
  column :column_name1, :column_type
  column :column_name2, :column_type
  column :column_name3, :column_type
  column :column_nameN, :column_type
  ...
end

Tipos de colunas (column_type) disponíveis:

  • :string
  • :text
  • :integer
  • :float
  • :decimal
  • :datetime
  • :timestamp
  • :time
  • :date
  • :binary
  • :boolean

Validações do ActiveRecord funcionam perfeitamente

1
2
3
4
5
6
7
8
9
10
11
class Contact < TablelessModel
  column :name, :string
  column :telephone, :string
  column :firm, :string
  column :email, :string
  column :message, :text
 
  validates_presence_of :name, :email, :message
  validates_format_of :email, :with => /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i
  validates_length_of :message, :minimum => 3
end

Exemplo completo usando tableless_scaffold gerador

Criar o tableless scaffold

./script/generate tableless_scaffold contact name:string telephone:string firm:string email:string message:text

Adicionar as validações no model

Abra o arquivo app/models/contact.rb e adicione as validações:

1
2
3
4
5
6
7
8
9
10
11
12
class Contact < TablelessModel
  column :name, :string
  column :telephone, :string
  column :firm, :string
  column :email, :string
  column :message, :text
 
  # Validations
  validates_presence_of :name, :email, :message
  validates_format_of :email, :with => /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i
  validates_length_of :message, :minimum => 3
end

Execute

./script/server

Abra o seu navegador em: http://localhost:3000/contacts/new

Exemplo completo usando tableless_model gerador

Criar tableless model

./script/generate tableless_model contact name:string telephone:string firm:string email:string message:text

Adicionar as validações no model

Abra o arquivo app/models/contact.rb e adicione as validações:

1
2
3
4
5
6
7
8
9
10
11
12
class Contact < TablelessModel
  column :name, :string
  column :telephone, :string
  column :firm, :string
  column :email, :string
  column :message, :text
 
  # Validations
  validates_presence_of :name, :email, :message
  validates_format_of :email, :with => /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i
  validates_length_of :message, :minimum => 3
end

Criar o controlador

./script/generate controller contacts new create

Adicionar os códigos das actions:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class ContactController < ApplicationController
  def new
    @contact = Contact.new
  end
 
  def create
    @contact = Contact.new(params[:contact])
 
    if @contact.save # or @contact.valid?
      flash[:notice] = "Contact email sent successfully."
 
      # Send contact email
      #MyMailer.deliver_contact(@contact)
 
      redirect_to new_contact_path
    else
      render :action => "new"
    end
  end
end

Criar as routas para os contacts

Abra o arquivo config/routes.rb e adicione a linha:

1
2
3
4
ActionController::Routing::Routes.draw do |map|
  map.resources :contacts, :only => [:new, :create]
  ...
end

Criar o formulário de contato

Abra o arquivo app/views/contacts/new.html.erb e adicione o conteúdo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<% form_for(@contact) do |f| %>
  <%= f.error_messages %>
 
  <%= f.label :name %>
  <%= f.text_field :name %>
 
  <%= f.label :telephone %>
  <%= f.text_field :telephone %>
 
  <%= f.label :firm %>
  <%= f.text_field :firm %>
 
  <%= f.label :email %>
  <%= f.text_field :email %>
 
  <%= f.label :message %>
  <%= f.text_area :message %>
 
  <%= f.submit "Send" %>
<% end %>

Apague o arquivo app/views/contacts/create.html.erb.

Execute

./script/server

Abra o seu navegador em: http://localhost:3000/contacts/new

Documentação

http://lab.patrickespake.com/tableless_model

Código fonte

http://github.com/patrickespake/tableless_model

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

  • Share/Bookmark

Ruby on Rails ActiveRecord como excluir registros dependentes e arquivos anexados com o Paperclip

Postado em 10 jun 2009
Categoria(s) Ruby on Rails

Digamos que você tenha uma mensagem, e essa mensagem possa ter várias fotos e vídeos relacionadas com ela.

Com o model message.rb da forma abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Message < ActiveRecord::Base
  # associações
  belongs_to :user
  has_many :photos
  has_many :videos
 
  # validações
  # presença
  validates_presence_of :title
  validates_presence_of :content
 
  # tamanho máximo
  validates_length_of :title, :maximum => 255
end

Se você usar Paperclip para anexar as fotos e vídeos, quando você apagar uma mensagem os arquivos de fotos e vídeos iram continuar a existir no disco rígido.

Para forçar que todas as relações filhas sejam apagadas quando você excluir a mensagem, você deve adicionar :dependent => :destroy na declaração has_many, ficando assim:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Message < ActiveRecord::Base
  # associações
  belongs_to :user
  has_many :photos, :dependent => :destroy
  has_many :videos, :dependent => :destroy
 
  # validações
  # presença
  validates_presence_of :title
  validates_presence_of :content
 
  # tamanho máximo
  validates_length_of :title, :maximum => 255
end

Essa alteração força para que todos os dependentes sejam excluídos.

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

  • Share/Bookmark

Ruby on Rails como usar callbacks do plugin Paperclip

Postado em 20 abr 2009
Categoria(s) Ruby on Rails

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: Recommend Me.

  • Share/Bookmark

Ruby on Rails Usando Rotas dentro do Model

Postado em 09 abr 2009
Categoria(s) Ruby on Rails

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: Recommend Me.

  • Share/Bookmark