Objetivo

Este documento tem como objetivo mostrar como deve ser criado uma nova classe que será colocada dentro de um fluxo do PDV, durante as customizações e desenvolvimento de novas funcionalidades.


Arquitetura

Para uma classe ser aceita dentro de um fluxo do PDV, ela precisa seguir algumas regras. 
A primeira regra é que ela obrigatoriamente precisa herdar de com.csi.statemachine.ExecutableFlowObject ou herdar de alguma outra classe que já possua essa herança. Por convenção, as classes que recebem essa herança, devem ser nomeadas com o prefixo EFO, um exemplo de nomenclatura seria EFOMinhaClasse.java.
ExecutableFlowObject é uma classe abstrata, onde quem herda precisa implementar o método execute(). Essa é a segunda regra, cujo método execute precisa retornar um ExecutionResult. Este será utilizado para determinar qual o caminho deve ser seguido no fluxo da operação que está sendo executada pelo PDV.
Mais abaixo vamos demonstrar com exemplos de código, como essas classes devem ser criadas.


Exemplo Prático

Abaixo veremos como devemos criar uma nova EFO que será utilizada dentro de um fluxo de uma operação no PDV.


Criação da classe

Ao lado temos um exemplo de como uma EFO deve ser criada. Essa classe terá a função de processar um pagamento de fatura. Logo, vamos definir um nome que deixe claro o objetivo dela. Não podemos esquecer o prefixo EFO.

Ela herda de ExecutableFlowObject e, além disso, já criamos a classe com uma implementação mínima do método execute().

Criando uma nova EFO
package com.linx.storex.custom.negocio.executavel;

import java.util.Map;

import com.csi.statemachine.ExecutableFlowObject;
import com.csi.statemachine.ExecutionResult;
import com.csi.statemachine.State;
import com.csi.statemachine.StateChangeRequest;

public class EFOPagamentoFatura extends ExecutableFlowObject {

   @Override
   public ExecutionResult execute(StateChangeRequest arg0, State arg1, Map arg2) {
	  // TODO Auto-generated method stub
	  return null;
   }

}

Definição das saídas (ExecutionResult)

Vamos agora definir as saídas dessa EFO, ou seja, os resultados possíveis que o método execute poderá retornar. Esses resultados serão referenciados no diagrama de fluxo da operação (isso será demonstrado mais para frente).

Ao lado podemos ver duas constantes, que representam as saídas possíveis para a execução do método execute() da classe EFOPagamentoFatura. São elas:

  1. PAGAMENTO_REALIZADO
  2. PAGAMENTO_NAO_REALIZADO




Definindo saídas
package com.linx.storex.custom.negocio.executavel;

import java.util.Map;

import com.csi.statemachine.ExecutableFlowObject;
import com.csi.statemachine.ExecutionResult;
import com.csi.statemachine.State;
import com.csi.statemachine.StateChangeRequest;

public class EFOPagamentoFatura extends ExecutableFlowObject {


  private static ExecutionResult PAGAMENTO_REALIZADO = new ExecutionResult("PAGAMENTO_REALIZADO");
  private static ExecutionResult PAGAMENTO_NAO_REALIZADO = new ExecutionResult("PAGAMENTO_NAO_REALIZADO");

  @Override
  public ExecutionResult execute(StateChangeRequest stateChangeRequest , State state, Map map) {
	 // TODO Auto-generated method stub
	 return null;
  }

}

Método execute()


Agora vamos mostrar um exemplo de implementação do método execute(), fazendo uso das constantes definidas no exemplo acima.

O método execute() recebe alguns parâmetros, que são passados entre as EFOs executadas em um fluxo.

São eles:

  1. StateChangeRequest → Este possui a informação de qual evento foi responsável por iniciar o fluxo.
  2. State → Este possui a informação do estado atual do componente. Por exemplo: DISPONIVEL.
  3. Map → Este é usado para passar informações de uma EFO para outra. Ou seja, quaisquer informações setadas dentro desse map, poderão ser utilizadas nas demais EFOs executadas ao longo do fluxo.






















Na imagem ao lado, podemos ver a representação gráfica da EFOPagamentoFatura com as duas saídas implementadas no exemplo acima: PAGAMENTO_REALIZADO e PAGAMENTO_NAO_REALIZADO.

Implementando método execute()
private static ExecutionResult PAGAMENTO_REALIZADO = new ExecutionResult("PAGAMENTO_REALIZADO");
private static ExecutionResult PAGAMENTO_NAO_REALIZADO = new ExecutionResult("PAGAMENTO_NAO_REALIZADO");


@Override
public ExecutionResult execute(StateChangeRequest stateChangeRequest, State state, Map map) {
	
	GerenciadorCMOS cmos = (GerenciadorCMOS) Componente.getInstance().getPerifericos().getCmos();
	
	// Para ser possível fazer um pagamento de fatura, é preciso existir um cliente na CMOS.
    // Caso não exista, a execução do método é interrompida e retorna PAGAMENTO_NAO_REALIZADO.
	if(cmos.getClienteProprio() == null) {
		return PAGAMENTO_NAO_REALIZADO;
	}
	
	// Pega o cliente da CMOS e converte para o objeto que será utilizado na tela de pagamento de fatura.
	ClienteProprio clienteProprio = cmos.getClienteProprio();
	ClienteProprioVO clienteVO = montaClienteProprioVO(clienteProprio);
	
	if(clienteVO == null) {
		return PAGAMENTO_NAO_REALIZADO;
	}
	
	try {
		exibeTelaEProcessaPagamentoFatura(clienteVO, map);
	} catch(Exception e) {
		return PAGAMENTO_NAO_REALIZADO;
	}
	
	// Após o processamento da EFO, o método retorna PAGAMENTO_REALIZADO.
	return PAGAMENTO_REALIZADO;

}

private void exibeTelaEProcessaPagamentoFatura(ClienteProprioVO clienteVO, Map map) {
	// implementação do método
}

private ClienteProprioVO montaClienteProprioVO(ClienteProprio clienteProprio) {
	// implementação do método
}


  • Sem rótulos