public String add() throws Exception {
 
         int result = model.addCliente();
         if (result == Cliente.OK) {
             return SUCCESS;
         } else if (result == Cliente.COSTUMER_ALREADY_EXISTS) {
             addError("cliente", COSTUMER_ALREADY_EXISTS_ERROR);
             return ERROR;
         }
     }
 

         action("Cliente", ClienteAction.class)
         
         .on(SUCCESS, redir("addCli.jsp"))
         .on(ERROR, fwd("addCli.jsp"))
     
         .filter(common)
         .filter(new VOFilter(Cliente.class, "cliente"))
         .filter(new ValidatorCliente())
         .filter(new InjectionFilter());
 

 public class ValidatorCliente extends ValidationFilter {
      public void initValidator() {
               add("cliente", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
               add("cliente", new StringRule(3, 50), INVALID_LENGTH);
               add("cliente", new RegexRule(NAME_PATTERN), INVALID_CHARACTERS);
 
               add("nomeContato", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
               add("nomeContato", new StringRule(6, 50), INVALID_LENGTH);
               add("nomeContato", new RegexRule(NAME_PATTERN), INVALID_CHARACTERS);	                        
 
                add("email", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
                add("email", new StringRule(6, 50), INVALID_LENGTH);
                 add("email", new EmailRule(), INVALID_CHARACTERS);
       }
 	 
     private static final String NAME_PATTERN = "^[a-zA-Z0-9\\.\\-\\_]+$";
     private static final int FIELD_REQUIRED_ERROR = 3;
     private static final int INVALID_LENGTH = 4;
     private static final int INVALID_CHARACTERS = 5;  
 
     public String execute() throws Exception {
         throw new ActionException("Nothing here!");
     }
 	
 }
 
 

     public String add() throws Exception {
 
        int result = model.adicionar();
         if (result == Cliente.OK) {
             return SUCCESS;
         } else if (result == Cliente.USERNAME_ALREADY_EXISTS) {
             addError(USERNAME_ALREADY_EXISTS_ERROR);
             return ERROR;
         } else if (result == Cliente.COSTUMER_ALREADY_EXISTS) {
             addError(COSTUMER_ALREADY_EXISTS_ERROR);
             return ERROR;
         }
         return ERROR;
     }
 

   
 
 public class ClienteAction extends BaseAction implements ModelDriven, Validatable  {
 	 
     public static final String ERROR2 = "error2";
     public static final String NOCLIENTES = "noclientes";
     private static final String NAME_PATTERN = "^[a-zA-Z0-9\\.\\-\\_]+$";
     private static final int USERNAME_ALREADY_EXISTS_ERROR = 1;
     private static final int COSTUMER_ALREADY_EXISTS_ERROR = 2;  
     private static final int FIELD_REQUIRED_ERROR = 3;
     private static final int INVALID_LENGTH = 4;
     private static final int INVALID_CHARACTERS = 5; 
     
     private Cliente model = new Cliente();
     
     public Object getModel() {
         return model;
     }
  public String add() throws Exception {    	        	    	
         int result = model.addCliente();
         if (result == Cliente.OK) {
             return SUCCESS;
         } else if (result == Cliente.USERNAME_ALREADY_EXISTS) {
             addError(USERNAME_ALREADY_EXISTS_ERROR);
             return ERROR;
         } else if (result == Cliente.COSTUMER_ALREADY_EXISTS) {
             addError(COSTUMER_ALREADY_EXISTS_ERROR);
             return ERROR;
         }
         return ERROR;
     }
 
 public String execute() throws Exception {
         throw new ActionException("Nothing here!");
     }
     
     public void initValidator(Validator val, String innerAction) {
 	        
 		 if (innerAction != null && innerAction.equals("add")) {
 			 
 			 val.add("cliEmp", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
 			 val.add("cliEmp", new StringRule(3, 50), INVALID_LENGTH);
 			 val.add("cliEmp", new RegexRule(NAME_PATTERN), INVALID_CHARACTERS);
 	
 			 val.add("cliUsu", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
 			 val.add("cliUsu", new StringRule(6, 50), INVALID_LENGTH);
 			 val.add("cliUsu", new RegexRule(NAME_PATTERN), INVALID_CHARACTERS);
 		                        
 			 val.add("cliNomRes", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
 			 val.add("cliNomRes", new StringRule(4, 50), INVALID_LENGTH);
 			 val.add("cliNomRes", new RegexRule(NAME_PATTERN), INVALID_CHARACTERS);
 	
 			 val.add("cliEma", new RequiredFieldRule(), FIELD_REQUIRED_ERROR);
 			 val.add("cliEma", new StringRule(6, 50), INVALID_LENGTH);
 			 val.add("cliEma", new EmailRule(), INVALID_CHARACTERS);
 	           
 	    }
     }
 
 

 
     private ClienteDAO clienteDAO = null;
     private Cli cli = null;
     
     public Cliente() { }
     
     public void setClienteDAO(ClienteDAO clienteDAO) {
         this.clienteDAO = clienteDAO;
     }
 
     public void setCli(Cli cli) {
         this.cli = cli;
     }
     
     public Cli getCli() {
         return cli;
     }
     
     public int addCliente() throws Exception {
     	
     	if (clienteDAO == null) throw new IllegalStateException("clienteDAO is not set for Registration!");
     	if (cli == null) throw new IllegalStateException("no user for Registration!");
 
     	// make username, password and email lowercase...
         cli.setCliEmp(cli.getCliEmp().toUpperCase());        
         cli.setCliNomRes(cli.getCliNomRes().toUpperCase());
         cli.setCliUsu(cli.getCliUsu());
         cli.setCliEma(cli.getCliEma());
         cli.setCliLog(cli.getCliLog());
         cli.setCliBai(cli.getCliBai());
         cli.setCliCid(cli.getCliCid());
         cli.setCliUf(cli.getCliUf());
         cli.setCliCep(cli.getCliCep());
                 
         // check if username already exists...
         Cli c = clienteDAO.loadByEmpresa(cli.getCliEmp());
         if (c != null) return COSTUMER_ALREADY_EXISTS;
         
         // check if email already exists...
         c = clienteDAO.loadByUser(cli.getCliUsu());
         if (c != null) return USERNAME_ALREADY_EXISTS;
         
         // register!
         clienteDAO.insertCliente(cli);
         
         return OK;
     }