Mensagens enviadas por: joellobo

Rubem Azenha wrote:Utilizar REST para comunicação entre os módulos de um mesmo sistema que fica no mesmo servidor físico? Não conheço o seu projeto, mas não acho uma boa idéia.

Será que não da pra criar uma subcamada em cada módulo pra isolar as dependências entre um módulo e outro pra chamar "direto"? (Se a idéia é os módulos serem independentes e cada um ter o seu ciclo de vida)

De qualquer forma, eu acredito que o ideal seja criar uma abstração para não deixar cravado do sua lógica de neǵocio uma tecnologia de comunicação específica.

(PS: @yoshima compartilho o seu sentimento...)

Criar uma abstração pra isolar os módulos funciona mas com alguns problemas - é assim q trabalho hoje - por exemplo, p algumas alterações em um módulo eu preciso re-compilar e empacotar tudo.

Um EJB de um módulo acessando outro EJB de outro módulo está "cravado" uma tecnologia de comunicação. A diferença é que com REST eu não tenho dependência com tecnologia. Estou apenas utilizando um protocolo de aplicação.

Caros, qual a alternativa para os sistemas monolíticos? O que vcs acham de partitions + restful? Seria uma boa escolha mesmo sabendo que os módulos estariam no mesmo servidor fisicamente?

Caros, minha aplicação tem um módulo na internet e outro na intranet. Bem simples e comum. Por exemplo, temos um site com compras e um módulo na intranet onde é dado andamento aos pedidos. O servidor com a aplicação da internet está em uma DMZ (e todos os outros recursos de segurança). Como compartilhar a parte em comum (classes, módulos e etc)? Plugin, gem?

Grato

Guilherme Silveira wrote:Oi pesosoal tudo bem?

Criar um modelo que representa o que você espera é uma coisa, copiar os arquivos do remoto para o local é outra.
De qualquer maneira, o Restfulie não depende da criação de seu modelo no cliente, as docs tem alguns exemplos assim:

order = Restfulie.at(uri).get

ou ainda

Restfulie.at(uri)create {:amount =>500}.to_xml

Nenhum dos dois casos usa um modelo fixo no cliente!

Abraço!

Putz, era simplesmente isso que eu estava falando mas ainda não tinha visto que o restfulie fazia!!! Show de bola!!!

Sem mais perguntas, meritíssimo

Ficou mais claro quando vi o código da classe Order.

No cliente:

No server:

class Order < ActiveRecord::Base
  
  acts_as_restfulie do |order, transitions|
    transitions << :execute_it if (order.status == "preparing") && order.paid_one_minute_ago?
    transitions << [:thanks, { :action => :thanks }] if order.status == "received"
  end
  
  has_and_belongs_to_many :trainings
  has_many :payments

state :unpaid, :allow => [:latest, :pay, :cancel]
	state :cancelled, :allow => :latest
	state :received, :allow => [:latest, :check_payment_info]
	state :preparing, :allow => [:latest, :check_payment_info]
	state :ready, :allow => [:latest, :receive, :check_payment_info]# do |order|
#	  order.paid_one_minute_ago?
#	end
	
	transition :check_payment_info do |order|
	   {:controller => :payments, :action => :show, :order_id => order.id, :payment_id => order.payments[0].id, :rel => "check_payment_info"}
	end
	transition :latest, {:action => :show}, {:not_found => 404, :no_change => 304}
  transition :cancel, {:action => :destroy}, :cancelled
	  # 405 ==> (dont do it)
	  # 409 ==> (try again)
	  # order.status=="cancelled".... trying to cancel ==> 405
	  # order.status=="preparing".... trying to update it ==> 409
	  # order.status=="unpaid".... invalid data supplied ==> 400?
  transition :pay, {}, :preparing
	transition :receive, {}, :received
	transition :execute_it, {}, :ready

def paid_one_minute_ago?
    # takes one minute to be prepared
    self.paid_at < (Time.now - 1.minute)
  end
	
   def pay(payment)
     debugger
     move_to :pay
     self.paid_at = Time.now
     @payment = payment
     @payment.order = self
   end
  
  def total_price
    total = 0
    @trainings.each do |x|
      total += x.price
    end
    total
  end
  
  def paid?
    payments.size > 0
  end

# def can_cancel?
    #   raise 405 if @status == :cancelled
    #   # ...
    # end
  
end

Essa classe stub no cliente ainda não me parece uma boa ideia... Acredito que existe uma forma melhor mas ainda não sei como...

Vou ver como ficaria isso em Java. Vi um exemplo onde o NetBeans gera a classe JavaScript stub a partir de uma serviço REST. Acho isso muito SOAP!!! Onde está o desacoplamento se preciso gerar o cliente caso alguma mudança seja feita no server?

Achei

http://github.com/caelum/restfulie-client
http://github.com/caelum/restfulie-test

Tem como eu baixar o source dos live_examples (http://restfulie.caelum.com.br/restful_rails/live_examples)?

Caros, com base no short samples do restfulie: http://restfulie.caelum.com.br/restful_rails/short_samples

Se eu tenho esse código no cliente do serviço:
order = Order.from_web resource_uri

E esse código no server:
class Order < ActiveRecord::Base

acts_as_restfulie do |transitions|
transitions << [:show]
transitions << [:destroy] if can_cancel?
transitions << [:controller => :payments, :action => :create, {:id => id}] if can_pay?
end
end

Então, eu vou ter q ter a classe Order nos dois projetos! Isso não quebra a "First Law of Distributed Object Design: Don't distribute your objects (Fowler)"???

Foxlol wrote:
Mas então, postem alguns exemplos de estrutura que vcs usam nos projetos para eu ter uma idéia.

* com.app.doctor
* com.app.drug
* com.app.patient
* com.app.presription
* com.app.report
* com.app.security
* com.app.webmaster
* com.app.util
* and so on...

http://www.javapractices.com/topic/TopicAction.do?Id=205

Além dos acima citados gosto desses:
Refactoring: Improving the Design of Existing Code
The Pragmatic Programmer

Segurança, usabilidade e etc são importantes na maioria dos casos mas acho que o domínio da aplicação é a mais desprestigiada. Ninguém deveria iniciar uma aplicação hoje sem ter conhecimento de DDD. Não que toda aplicação deva usar mas você deve conhecer DDD para decidir quando usar ou não. O Jimmy Nilsson tem um bom artigo aqui http://www.infoq.com/articles/CCC-Jimmy-Nilsson

rodrigoy wrote:Amigos(as),

Vocês consideram módulos e pacotes/namespaces a mesma coisa? Como vocês modularizam a aplicação de vocês e o que buscam com isso? (estou escrevendo sobre isso e gostaria de avaliar a visão do mercado)

Abrações!

Sim. Modules (Also known as Packages)

Acredito que a melhor forma é "Package by feature, not layer"

Caros, estou utilizando os jBehave 2.3 para automatizar meus testes de aceitação. Estou utilizando Selenium e o Padrão Page Objects. Minha dúvida é com relação aos GivenScenarios.

Por exemplo, tenho essas duas features:
Feature 1: Logar no sistema

As classes que implementam esses testes são: LogarSistema e LogarSteps

Feature 2: Cadastrar Processo

As classes que implementam esses testes são: CadastrarProcesso e CadastrarSteps

A Feature 2 deve executar a Feature 1 antes e estou utilizando GivenScenarios para isso.

Quando executo os testes da feature 2 a aplicação executa a feature 1 mas não encontra os steps pois ele procura na classe CadastrarSteps e não na LogarSteps.

É assim mesmo que funciona os GivenScenarios? O que estou fazendo de errado? Como não ter essa dependência?

entenda que reserva aqui e o que diz se um quarto esta disponivel ou nao

Será que é isso que o cliente entende por reserva?

Opção 1. O repositório TodasReservas poderia ter um método como getQuartosReservados(periodo):Quartos mas não getQuartosDisponiveis(periodo):Quartos. Apesar de ter exceções, como no exemplo do seu post (Yoshima), a regra 1 repository para cada aggregate está resolvendo a maioria dos meus problemas.

Notícias, artigos e o maior fórum brasileiro sobre Java