WebOrb tem se demonstrado muito bom no seu trabalho, estou gostando de desenvolver com ele, após descobrir que qualquer classe do ruby, não apenas as classes Service podem ser usadas como objetos remotos, fiquei muito feliz e logo tive boas experiências.

Boas experiências é poder chamar um ActiveRecord puramente apartir do flex:

remoteObject = new RemoteObject();
remoteObject.destination = "Person";
remoteObject.all({"include": "address", 
                           "conditions": ["age > ?",18]});

Para isso apenas foi necessário alguns passos:

Adicionar a configuração do serviço remoto:

Para trabalhar com weborb, existe um arquivo no projeto em que são mapeados os serviços, por padrão está em:

Rails.root/config/WEB-INF/flex/remoting-config.xml

Neste arquivo deve ser adicionado o mapeamento entre as classes:

<destination id="Person">
  <properties>
    <source>Person</source>
  </properties>
</destination>

Adicionar mapeamento dos modelos

Após isso, é necessário configurar a classe ActionScript que irá receber o modelo, para ser possível recuperar as informações. O arquivo agora é:

Rails.root/config/weborb-config.xml
<classMapping>
  <clientClass>com.model.Person</clientClass>
  <serverClass>Person</serverClass>
  <source>Person</source>
</classMapping>
<classMapping>
  <clientClass>com.model.Address</clientClass>
  <serverClass>Address</serverClass>
  <source>Person</source>
</classMapping>

Verificar os modelos do Rails

No model, sabe-se que é usado classes ActiveRecord como:

class Person < ActiveRecord::Base
   belongs_to :address
end
class Address < ActiveRecord::Base
end

Verificar os modelos do ActionScript

A classe model do ActionScript deve possuir os atributos que serão instanciados no Flex:

package com.model {
  [RemoteClass(alias="com.model.Person")]
  public class Person {
    public var name:String;
    public var age:Number;
    public var address:Address;
    
    public function Person() {
    }
  }
}

Compatibilizar os hashs do Rails e ActionScript

Após isso, existe um pequeno problema entre as classes que são usadas como serviços, que o Hash do flex, converte as chaves como string, por não possuir símbolos, então é necessário fazer um pequeno hack no método find por exemplo:

module SymbolizeArgs 
  module ClassMethods
    # this hack should be used by remoteObjects 
    # that just pass a Hash with string keys
    # because this we need to symbolize the keys
    def find_with_simbolyzed_keys( *args ) 
      options = {}
      old_options = args.extract_options!
      old_options.each{|key,value|
        if key.kind_of?(String) 
          options[key.to_sym] = value 
        else
          options[key] = value
        end
      }
      args.push options
      find_without_simbolyzed_keys *args
    end
  end

  def self.included(base)
    base.class_eval do
      extend ClassMethods
      class << self
        alias_method_chain :find, :simbolyzed_keys
      end
    end
  end  
end

module ActiveRecord
  class Base
    include SymbolizeArgs
  end
end

O código acima pode ficar na pasta/arquivo: Rails.root/config/initializers/active_record_simbolyze_keys.rb

Com esta alteração é possível usufruir do método find com todos os seus benefícios, de uma maneira fácil, a classe ActiveRecord fica totalmente exposta ao ActionScript.

Se o código acima não for ativado, você receberá um erro como: "Unknown key(s): conditions (ArgumentError)"

ps: Inspirado em: http://onrails.org/articles/2006/10/29/part-1-using-weborb-to-access-activerecords-from-a-flex-application


blog comments powered by Disqus
Compartilhar → Twitter Facebook Google+


Olá, sou o Jônatas Davi Paganini e esse é meu blog. Sou programador, tenho alguns projetos no github e escrevo livremente aqui no ideia.me.

Veja minhas talks ou conecte-se via twitter / github / instagram / facebook / linkedin / soundcloud / strava / meetup.