here

Bom Dia Galera..

Bom como eu tava precisando muito disso resolvi fazer funcionar e agora vo disponibiliza aqui pra galera que se interessar...

Os créditos vão para o Velo que começou o trabalho e me passou eu só fiz alguns ajustes e mexi em algumas coisas mas o trabalho mais sujo foi dele..

primeiro foi criado um novo controller

org.mentawai.core.FlexControleller

Code:

package org.mentawai.core;
 
 import java.io.IOException;
 
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletContext;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.mentawai.flex.FlexFilter;
 
 /**
  * @author Velo
  * @author Fabiano Frizzo(ffrizzo at gmail.com)
  */
 public class FlexController extends Controller {
 
 	private static final long serialVersionUID = 7470880575373129990L;
 	
 	public static final String INNER_ACTION_NAME = "innerActionName";
 	public static final String ACTION_NAME = "actionName";
     public static final String MENTA_CONTROLLER = "menta_controller";
     
     @Override
     public void init(ServletConfig conf) throws ServletException {
     	super.init(conf);
 
         //verifies if the flex mode is on (default false)
     	if (flexMode){
     		appContext.setAttribute(MENTA_CONTROLLER, this);
     	}
     }
     
     @Override
     protected String getActionName(HttpServletRequest req) {
     	return (String) FlexFilter.input.get().getValue(ACTION_NAME);
     }
     
     @Override
     protected String getInnerActionName(HttpServletRequest req) {
     	return (String) FlexFilter.input.get().getValue(INNER_ACTION_NAME);
     }
 
     @Override
     protected void service(HttpServletRequest req, HttpServletResponse res)
     		throws ServletException, IOException {
     	super.service(req, res);
     }
 }

ai criei mais dois pacotes

org.mentawai.flex e org.mentawai.flex.granite

no pacote flex temos as classes

Code:

package org.mentawai.flex;
 
 import java.util.Iterator;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.mentawai.core.Action;
 import org.mentawai.core.Consequence;
 import org.mentawai.core.ConsequenceException;
 
 /**
  * 
  * @author Velo
  * @author Fabiano Frizzo
  */
 public class FlexConsequence implements Consequence {
 	
 	public FlexConsequence() {
 
 	}
 
 	public void execute(Action a, HttpServletRequest req,
 			HttpServletResponse res) throws ConsequenceException {
 		Iterator<String> keys = a.getOutput().keys();
 		while (keys.hasNext()) {
 			String key = (String) keys.next();
 			Object value = a.getOutput().getValue(key);
 
 			req.setAttribute(key, value );
 		}
 	}
 
 
 }

e

Code:

package org.mentawai.flex;
 
 import org.mentawai.core.Action;
 import org.mentawai.core.Filter;
 import org.mentawai.core.Input;
 import org.mentawai.core.InvocationChain;
 import org.mentawai.core.Output;
 
 /**
  * 
  * @author Velo
  * @author Fabiano Frizzo
  */
 public class FlexFilter implements Filter {
 	
 	public static final ThreadLocal<Input> input = new ThreadLocal<Input>();
 
 	public static final ThreadLocal<Output> output = new ThreadLocal<Output>();
 
 	public FlexFilter() {
 	}
 	
 	public void destroy() {
 	}
 
 	public String filter(InvocationChain chain) throws Exception {
 		Action ac = chain.getAction();
 		ac.setInput(input.get());
 		try {
 			return chain.invoke();
 		} finally {
 			output.set(ac.getOutput());
 		}
 	}
 
 }

e no pacote granite temos

Code:

package org.mentawai.flex.granite;
 
 import java.io.IOException;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.mentawai.core.Controller;
 import org.mentawai.core.Output;
 import org.mentawai.core.RequestInput;
 import org.mentawai.core.ResponseOutput;
 import org.mentawai.flex.FlexFilter;
 
 /**
  * 
  * @author Velo
  * @author Fabiano Frizzo
  */
 public class GraniteInvoker {
 
 	private Controller controller;
 	private HttpServletRequest req;
 	private HttpServletResponse res;
 
 	public GraniteInvoker(Controller controller, HttpServletRequest req,
 			HttpServletResponse res) {
 		super();
 		this.controller = controller;
 		this.req = req;
 		this.res = res;
 	}
 
 	public Map<String, Object> invokeAction(Map<String, Object> parameters)
 			throws ServletException, IOException {
 		RequestInput input = new RequestInput(req);
 		toInput(input, parameters);
 		FlexFilter.input.set(input);
 		
 		ResponseOutput output = new ResponseOutput(res);
 		FlexFilter.output.set(output);
 		
 		controller.service(req, res);
 		return toMap(FlexFilter.output.get());
 
 	}
 
 	private void toInput(RequestInput input, Map<String, Object> parameters) {
 		Set<String> keys = parameters.keySet();
 		for (String key : keys) {
 			input.setValue(key, parameters.get(key));
 		}
 	}
 
 	private Map<String, Object> toMap(Output output) {
 		Map<String, Object> map = new LinkedHashMap<String, Object>();
 		Iterator<String> keys = output.keys();
 		while (keys.hasNext()) {
 			String key = keys.next();
 			map.put(key, output.getValue(key));
 		}
 		return map;
 	}
 }

Code:

package org.mentawai.flex.granite;
 
 import org.granite.config.flex.Destination;
 import org.granite.context.GraniteContext;
 import org.granite.messaging.service.ServiceException;
 import org.granite.messaging.service.ServiceFactory;
 import org.granite.messaging.webapp.HttpGraniteContext;
 
 import flex.messaging.messages.RemotingMessage;
 
 /**
  * 
  * @author Velo
  * @author Fabiano Frizzo
  */
 public class GraniteServiceFactory extends ServiceFactory {
 	
 	public GraniteServiceFactory() {	}
 
 	private HttpGraniteContext getHttpContext() {
 		GraniteContext context = GraniteContext.getCurrentInstance();
 		if(!(context instanceof HttpGraniteContext)) {
 			throw new ServiceException("Unable to get ServletContext");
 		}
 		HttpGraniteContext httpContext = ((HttpGraniteContext) context);
 		return httpContext;
 	}
 
 	@Override
 	public GraniteServiceInvoker getServiceInstance(RemotingMessage request)
 			throws ServiceException {
         String messageType = request.getClass().getName();
         String destinationId = request.getDestination();
         
         HttpGraniteContext httpContext = getHttpContext();
         Destination destination = httpContext.getServicesConfig().findDestinationById(messageType, destinationId);
         
 		// Object bean = controller.getBean(beanName);
 		return new GraniteServiceInvoker(destination, this,
 				httpContext);
 	}
 }

Code:

package org.mentawai.flex.granite;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.granite.config.flex.Destination;
 import org.granite.messaging.service.ServiceException;
 import org.granite.messaging.service.ServiceInvoker;
 import org.granite.messaging.webapp.HttpGraniteContext;
 import org.mentawai.core.Controller;
 import org.mentawai.core.FlexController;
 
 /**
  * 
  * @author Velo
  * @author Fabiano Frizzo
  */
 public class GraniteServiceInvoker extends ServiceInvoker<GraniteServiceFactory> {
 	
 	public GraniteServiceInvoker(Destination destination,
 			GraniteServiceFactory factory, HttpGraniteContext context)
 			throws ServiceException {
 		
 		super(destination, factory);
 
 		ServletContext sc = context.getServletContext();
 		Controller controller = (Controller) sc
 				.getAttribute(FlexController.MENTA_CONTROLLER);
 		HttpServletRequest req = context.getRequest();
 		HttpServletResponse res = context.getResponse();
 		String actionName = destination.getId();
 
 		super.invokee = new GraniteInvoker(controller, req, res);
 	}
 }

Ainda to em duvida aonde eu posso colocar o MentaRPC.as que faz parte do flex
Code:

 package menta {
 
 	import bean_flex.Pessoa;
 	
 	import mx.controls.Alert;
 	import mx.core.Container;
 	import mx.managers.CursorManager;
 	import mx.rpc.events.FaultEvent;
 	import mx.rpc.events.InvokeEvent;
 	import mx.rpc.events.ResultEvent;
 	import mx.rpc.remoting.RemoteObject;
 	import mx.utils.ObjectUtil;
 
 
 	[Event(name=InvokeEvent.INVOKE, type="mx.rpc.events.InvokeEvent")]
 	[Event(name=ResultEvent.RESULT, type="mx.rpc.events.ResultEvent")]
 	[Event(name=FaultEvent.FAULT, type="mx.rpc.events.FaultEvent")]
 	public class MentaRPC extends Container {
 		private var ro:RemoteObject;
 		
 		public static var custonErrorHandler:Function;
 		
 		[Bindable]
 		public var input:Object = new Object();
 		[Bindable]
 		public var output:Object = new Object();
 		
 		public function MentaRPC(actionName:String=null, innerActionName:String = null){
 			ro = new RemoteObject();
 			ro.destination = "mentawaiamf";
 			ro.addEventListener(FaultEvent.FAULT, dispatchFault);
 			ro.addEventListener(ResultEvent.RESULT, dispatchResult);
 			ro.addEventListener(InvokeEvent.INVOKE, dispatchInvoke);
 
 			this.addEventListener(FaultEvent.FAULT, defaultFault);
 
 			input.actionName = actionName;
 			input.innerActionName = innerActionName;
 		}
 
 		public function set action(actionName:String):void {
 			input.actionName = actionName;
 		}
 
 		public function set innerAction(innerActionName:String):void {
 			input.innerActionName = innerActionName;
 		}
 
 		private function dispatchFault(e:FaultEvent):void {
 			CursorManager.removeBusyCursor();
 			dispatchEvent(e);
 		}
 		
 		private function dispatchResult(e:ResultEvent):void {
 			CursorManager.removeBusyCursor();
 			output = e.result;
 			dispatchEvent(e);
 		}
 		
 		private function dispatchInvoke(e:InvokeEvent):void {
 			CursorManager.setBusyCursor();
 			dispatchEvent(e);
 		}
 
 		override public function addEventListener(type:String,
 listener:Function, useCapture:Boolean = false, 
 priority:int = 0, 
 useWeakReference:Boolean = false):void{
 			if(type == FaultEvent.FAULT){
 				this.removeEventListener(FaultEvent.FAULT, defaultFault);
 			}
 			super.addEventListener(type, listener);
 		}
 
 		public function addParameter(name:String, value:Object):void {
 			input[name] = value
 		}
 
 		public function execute(func:Function = null):void {
 			if(func != null) {
 				this.addEventListener(ResultEvent.RESULT, func);
 			}
 			ro.invokeAction(input);
 		}
 		
 		private function defaultFault(f:FaultEvent):void{
 			if(custonErrorHandler != null) {
 				custonErrorHandler(f);
 			} else {
 				trace("No default fault handle defined, using alert!\n" + ObjectUtil.toString(f.fault));
 				Alert.show(f.fault.toString());
 			}
 		}
 		
 	}
 }

Agora o Exemplo de configuração do Menta com o Flex no Web.xml e no services-config.xml

web.xml

Code:

 	<filter>
 		<filter-name>AMFMessageFilter</filter-name>
 		<filter-class>org.granite.messaging.webapp.AMFMessageFilter</filter-class>
 	</filter>
 
 	<filter-mapping>
 		<filter-name>AMFMessageFilter</filter-name>
 		<url-pattern>/graniteamf/*</url-pattern>
 	</filter-mapping>
 
 
 	<!-- The Mentawai controller -->
 	<servlet>
 		<servlet-name>Controller</servlet-name>
 		<servlet-class>org.mentawai.core.FlexController</servlet-class>
 		<load-on-startup>1</load-on-startup>
 	</servlet>
 	
 	<servlet-mapping>
 		<servlet-name>Controller</servlet-name>
 		<url-pattern>*.mtw</url-pattern>
 	</servlet-mapping>
 	
 
 	<servlet>
 		<servlet-name>AMFMessageServlet</servlet-name>
 		<servlet-class>org.granite.messaging.webapp.AMFMessageServlet</servlet-class>
 
 		<load-on-startup>1</load-on-startup>
 	</servlet>
 
 	<!-- You must choose an extension to indicate a mentawai action -->
 	<servlet-mapping>
 		<servlet-name>AMFMessageServlet</servlet-name>
 		<url-pattern>/graniteamf/*</url-pattern>
 	</servlet-mapping>

services-config.xml
Code:

<services-config>
 	<services>
 		<service id="granite-service"
 class="flex.messaging.services.RemotingService"
 messageTypes="flex.messaging.messages.RemotingMessage">
 			<destination id="mentawaiamf">
 				<channels>
 					<channel ref="my-graniteamf" />
 				</channels>
 				<properties>
 					<factory>mentawaiFactory</factory>
 					<source>mentaSource</source>
 				</properties>
 			</destination>
 		</service>
 	</services>
 
 	<factories>								 
 		<factory id="mentawaiFactory" class="org.mentawai.flex.granite.GraniteServiceFactory" />
 	</factories>
 
 	<channels>
 		<channel-definition id="my-graniteamf" class="mx.messaging.channels.AMFChannel">
 			<endpoint uri="http://{server.name}:{server.port}/{context.root}/graniteamf/amf"
 class="flex.messaging.endpoints.AMFEndpoint" />
 		</channel-definition>
 	</channels>
 
 </services-config>

Esse exemplo de configuração se da para o GraniteDS o qual foi implementado inicialmente para o Menta funcionar com o Flex usando RemoteObjects..

Ja comecei a mexer para funcionar também com o BlazeDS daqui alguns dias ja devemos ter algo..

Exemplo de um mxml do flex

Code:

 <?xml version="1.0" encoding="utf-8"?>
 <mx:Application 
 	xmlns:mx="http://www.adobe.com/2006/mxml"
 	xmlns:rpc="menta.*" 
 	layout="absolute">
 <mx:Script>
 	<![CDATA[
 		import mx.rpc.events.ResultEvent;
 		import mx.controls.Alert;
 		import bean_flex.Pessoa;
 		import menta.MentaRPC;
 		
 			private function startUp():void {
 				var u:Pessoa = new Pessoa();
 				u.nome = nome.text;
 				u.sobreNome = sobrenome.text;
 				rpc.input.pessoa = u;
 				
 				rpc.execute(changeState);		
 			}
 
 			private function changeState(e:ResultEvent):void {
 				var u:Pessoa = rpc.output.pessoa;
 				Alert.show("Flex com o Menta ");
 
 			}		
 	]]>
 </mx:Script>
 
 
     <rpc:MentaRPC id="rpc" action="TesteAction" innerAction="teste" width="25" height="21"/>
     
 	<mx:Form width="50%" left="176" top="174" id="form1">
 		<mx:FormItem label="Nome:" >
 			<mx:TextInput id="nome"/>
 		</mx:FormItem>
 		<mx:FormItem label="Sobrenome:" >
 			<mx:TextInput id="sobrenome"/>
 		</mx:FormItem>
 	</mx:Form>
 
 	<mx:Button x="462" y="264" label="Submit" click="startUp()" id="button1"/>
 
 </mx:Application>

Um exemplo do ApplicationManager

Code:

public class ApplicationManager extends org.mentawai.core.ApplicationManager {
 
 	@Override
 	public void init(Context application) {
 		setFlexMode(true);
 	}
 	
 	@Override
 	public void loadActions() {
 		
 		filter(new FlexFilter());
 		
 		action(TesteAction.class, "teste")
 		.on(SUCCESS, new FlexConsequence());
 	}
 	
 }

E a action fica normal

Code:

 public class TesteAction extends BaseAction {
 
 	public String teste()throws Exception{
 		System.out.println("Action TesteAction");
 		
 		Pessoa pessoa = (Pessoa)input.getValue("pessoa");
 		System.out.println("Pessoa: "+pessoa);
 		
 		pessoa.setNome(pessoa.getNome().toUpperCase());
 		
 		output.setValue("pessoa", pessoa);
 		
 		return SUCCESS;
 	}
 }

Axo que é isso

Espero que gostem da maneira como foi implementada e que seja util para mais pessoas..

Tava pensando em criar um novo Projeto para essa integração do menta com o Flex ou seria melhor deixar junto com o projeto original do menta...

Obrigado pela atenção de todos e desculpa pelo enorme post...

Fabricio,
muito show, eu estou desenvolvendo um projeto com flex menta e blazeDS, porem to usando o menta somente para gerar os relatorios. Qdo vai ter uma versão para o blazeDS?

fiote wrote:

Fabricio,
muito show, eu estou desenvolvendo um projeto com flex menta e blazeDS, porem to usando o menta somente para gerar os relatorios. Qdo vai ter uma versão para o blazeDS?

Obrigado pelo incentivo...

E meu nome é Fabiano hauhauhauahuaha

Cara to trabalhando em cima do BlazeDS mas não tenho previsão pois tenho que terminar um projeto antes. Mas conforme vai surgindo ideias vou implementando ele e assim que tiver algo eu posto por aqui para a galera dar ideias

Obrigado pela sua atenção

Opa fabiano,

desculpa pela troca de nomes...huahuahuahuahua

O projeto q estou desenvolvendo é o www.fiote.com.br ja ta bem adiantado, no inicio tive q reescrever minhas classes de controller (q a turma chama de BO) quase todas para adaptar para o flex.

Se precisar de ajuda tamos na area.

fiote wrote:

Opa fabiano,

desculpa pela troca de nomes...huahuahuahuahua

O projeto q estou desenvolvendo é o www.fiote.com.br ja ta bem adiantado, no inicio tive q reescrever minhas classes de controller (q a turma chama de BO) quase todas para adaptar para o flex.

Se precisar de ajuda tamos na area.

Caramba ta ficando show heim

EU não sei fazer metade daquelas telas que vc fez muito show...

Se puder me add no msn ai

o_pia at hotmail . com

Rapaz acessei a sua app eu nunca tinha visto um sistema real(nosso mundo real) feito com flex muito bacana mesmo, tô pensando em colocar o flex na minha "lista de aprendizado".

bom trabalho !

Opa hélio,

Esse ta sendo o meu primeiro projeto, mas ta bem bacana. Tô em fase de implantação num cliente, pretendo terminar a implantação ainda este mês de julho.

pois é eu achei bacana porque é bem "realidade do cliente" eu sei que o flex pode fazer mais coisas mas isso dá uma sensação que a coisa realmente anda e funciona ..gostei parabéns e sucesso !

É acho que terei que colocar o flex na minha lista de aprendizado tb...

Eu ja tinha visto e ouvido falar, mas não achei que fosse taum interessante... bem bacana.

Opa... esqueci...

ffrizzo PARABENS cara muito legal, depois monta um CRUD simples acho que é interessante pra todos estudarem (inclusive eu).

Vamos esperar o nosso tio Sérgio, empurrar isso no menta.

IceW0lf wrote:

Opa... esqueci...

ffrizzo PARABENS cara muito legal, depois monta um CRUD simples acho que é interessante pra todos estudarem (inclusive eu).

Vamos esperar o nosso tio Sérgio, empurrar isso no menta.

Opa Obrigado Leiber.. Espero que isso ajude alguém

Assim que conseguir fazer a outra Parte que seria com o BlazeDS ai faço um exemplo bem pratico usando os dois...

Boa idéia a do CRUD ... ffrizzo parabéns não posso falar muita coisa porque não conheço flex mas estou pensando seriamente em conhecer !

Resucitando o tópico

Mas é por um bom motivo..

Bom Acabei agora a pouco de fazer a integração do BlazeDS com o Menta...
Não é nem um bicho de sete cabeças só estava meio sem tempo

Bom vou descrever aqui o que eu fiz para o BlazeDS..

Criei um novo pacote dentro dos que ja havia feito com o Nome blaze e dentro deste criei mais duas Classes

BlazeFactory.java e BlazeFactoryInstance.java

E a classe GraniteInvoker.java foi mudada para FlexInvoker.java

Pois ela serve tento para o Granite quanto para o Blaze

para a Aplicação funcionar com o blaze a unica coisa que precisa ser mudada é o Arquivo

services-config.xml
Code:

 <?xml version="1.0" encoding="UTF-8"?>
 <services-config>
 
 <!-- Configuração BlazeDS -->
     <services>
         <service-include file-path="remoting-config.xml"/>
     </services>
     
 	<factories>
 		<factory id="mentawaiFactory" class="org.mentawai.flex.blaze.BlazeFactory"/>
 	</factories>
 
     <channels>
 
     <channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel">
          <endpoint 
         	 url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" 
         	 class="flex.messaging.endpoints.AMFEndpoint"/>
     </channel-definition>
 
     <channel-definition id="my-secure-amf" class="mx.messaging.channels.SecureAMFChannel">
             <endpoint 
             	url="https://{server.name}:{server.port}/{context.root}/messagebroker/amfsecure" 
             	class="flex.messaging.endpoints.SecureAMFEndpoint"/>
             <properties>
                 <add-no-cache-headers>false</add-no-cache-headers>
             </properties>
         </channel-definition>
 
         <channel-definition id="my-polling-amf" class="mx.messaging.channels.AMFChannel">
             <endpoint 
             	url="http://{server.name}:{server.port}/{context.root}/messagebroker/amfpolling" 
             	class="flex.messaging.endpoints.AMFEndpoint"/>
             <properties>
                 <polling-enabled>true</polling-enabled>
                 <polling-interval-seconds>4</polling-interval-seconds>
             </properties>
         </channel-definition>
     </channels>
 
 	
 <!-- End BlazeDS -->	    
 	
 	<logging>
 		<target class="flex.messaging.log.ConsoleTarget" level="Error">
 			<properties>
 				<prefix>[Flex]</prefix>
 				<includeDate>true</includeDate>
 				<includeTime>false</includeTime>
 				<includeLevel>true</includeLevel>
 				<includeCategory>true</includeCategory>
 			</properties>
 			<filters>
 				<pattern>Endpoint.*</pattern>
 				<pattern>Service.*</pattern>
 				<pattern>Message.*</pattern>
 				<pattern>DataService.*</pattern>
 				<pattern>Configuration</pattern>
 			</filters>
 		</target>
 	</logging>	
 
 </services-config>

Reparem que nele só muda a parte aonde esta entre


E no remoting-config.xml fica da seguinte forma

Code:

<?xml version="1.0" encoding="UTF-8"?>
 <service id="remoting-service" 
     class="flex.messaging.services.RemotingService" 
     messageTypes="flex.messaging.messages.RemotingMessage">
 
 	<adapters>
 		<adapter-definition id="java-object"
 			class="flex.messaging.services.remoting.adapters.JavaAdapter"
 			default="true" />
 	</adapters>
 
     <default-channels>
         <channel ref="my-amf"/>
     </default-channels>
 
 	<destination id="mentawaiamf">
 		<properties>
 			<factory>mentawaiFactory</factory>
 			<source>mentaSource</source>
 		</properties>
 	</destination>    
 	
 </service>

Estou colocando um Jar Do Menta com as classes modificadas..
E também a Classe MentaRPC.as que ja está certa para fazer as chamadas ao Blaze..

Os Arquivos irão ficar nesse link aqui
http://www.4shared.com/dir/9133548/7bb0e616/Mentawai.html

Hoje a Noite faço um exemplo básico de utilização do Blaze e do Granie e posto aqui novamente..

Espero que isso possa contribuir de alguma forma para o Framework..

Se alguém quiser as classes modificadas é só pedir que eu mando...

Obrigado pela atenção de todos e Desculpa pelo tamanho do post

Show de bola cara....
Vou dar uma estudada e ver se uso isso nos meus Projetos..

Boa iniciativa, parabêns !

Mais um resucitamento

Bom como eu tava devendo um CRUD resolvi fazer ele agora a noite. e Terminei exatamente as 00:35 de hoje hehhehe

Espero que sirva para muitos a entender como está o funcionamento do Menta com o Flex..

E tem que usar o jar do menta que ta junto com o projeto.. Pois tem as classes do flex e também foi necessário alterar algumas classes do menta..

Na verdade fiz assim com a idéia de se algum dia for util integrar ao src do menta mesmo..

MentaFlexCRUD.rar

Forum Read-Only! Check the new site and forum here!