Thiago Galbiatti Vespa

ADF 11g adicionando auto sugestão em um input no ADF 11g é muito simples criar, o auto complementar para campos inputText, vejamos um exemplo.
Crie um projeto ADF Faces no JDeveloper 11g.

Clique em New Application, coloque um nome para o projeto, selecione Generic Application e clique em next.
Na caixa Avaliable selecione ADF Faces em clique no Add(ALT+D) veja:

Coloque um nome em seu projeto, clique em next se quiser alterar o nome padrão do primeiro pacote. Senão clique em Finish.

Crie uma nova página JSF.
Adicione à página que acabou de criar um componente af:inputText veja:

Com o botão direito clique sobre o inputText
Vá em Insert inside input text e clique em ADF Faces.

Na Janela que se abriu selecione Auto Suggest Behavior e clique em ok.

Aparecera a seguinte tela, para você setar o conjunto de itens que irá conter essa sugestão.
 

Bom ainda não criamos nenhum bean para esse projeto, teremos que criar agora vejamos:
Clique na seta para baixo na tela acima, aparecerá uma nova janela, clique em Edit.
Aparecerá outra janela em Managed Bean clique no botão New...
Crie seu Managed Bean.
Em Method clique em New... e de um nome para o método.
Ufaa =D
Veja:

 

Agora clique em OK e depois OK novamente.
Para demonstração vou colocar alguns itens fixo. Veja a implementação do nosso método.

   1: /**

   2:  *

   3:  * @param parâmetro contém o texto passado pelo value no nosso input text

   4:  * @return

   5:  */

   6: public List autoSugestao(String parametro) {

   7:     //array de nomes para o exemplo

   8:     String[] itensNomes = {"Abreu","Gonçalves","Junior","Alexandre","Andrade"};

   9:     

  10:     //Criando uma lista de SelectItem para o retorno que serão associados ao suggest

  11:     List<SelectItem> listNomesEncontrados = new ArrayList<SelectItem>();

  12:     for (String s : itensNomes) {

  13:         if(s.startsWith(parametro) || s.endsWith(parametro))

  14:             listNomesEncontrados.add(new SelectItem(s));

  15:     }

  16:     return listNomesEncontrados;

  17: }

Muito simples não =), veja o exemplo, abaixo funcionando.

É isso ai pessoal fica a dica. e bons códigos.
Abaixo o download do projeto.

 
Obrigado!

Marcadores: java, JDeveloper 11g

// postado por Cássio Sousa @ 22:10 0 Comentários Links para esta postagem

Uma das características do ADF 11g, é poder gerenciar um Popup, por um ManagedBean.
Crie um projeto no JDeveloper 11G
Como exemplo vou criar um projeto simples somente com um view, um bean e uma Página jsp.

Nesta Página insira um componente popup, dentro do popup insira um componente Dialog, para termos os botões ok e cancel por default.Set a propriedade  contentDelivery como lazy assim garantimos um “refresh” nos componentes.
Insira também um componente OutputText, para vermos as modificações.

Agora criaremos um ManagedBean para a nossa aplicação, insira também um botão ou qualquer outro componente que gere um evento na página jsp. Defina sua propriedade PartialSubmit como true veja

Crie um Action para o botão e defina como corpo do método como abaixo

   1: public String actionChamaPopup() {

   2:     FacesContext context = FacesContext.getCurrentInstance();

   3:  

   4:     StringBuilder script = new StringBuilder();

   5:     script.append("var popup = AdfPage.PAGE.findComponent('").append("popID").append("'); ").append("if (!popup.isPopupVisible()) { ").append("var hints = {}; \n" +

   6:             " hints[AdfRichPopup.HINT_ALIGN] = AdfRichPopup.ALIGN_AFTER_START;\n" +

   7:             " hints[AdfRichPopup.HINT_ALIGN_ID] = 'botaoID';\n ").append("popup.show(hints);}");

   8:     ExtendedRenderKitService erks =

   9:         Service.getService(context.getRenderKit(),

  10:                            ExtendedRenderKitService.class);

  11:     erks.addScript(context, script.toString());

  12:     setTexto("Exemplo");

  13:     return null;

  14: }

Neste método você descreve o script para chamar a popup,  define o alinhamento, e quem a popup deve pegar como base para se alinhar

Posições de alinhamento
ALIGN_AFTER_START
ALIGN_AFTER_END
ALIGN_BEFORE_START
ALIGN_BEFORE_END
ALIGN_END_AFTER
ALIGN_END_BEFORE
ALIGN_START_AFTER
ALIGN_START_BEFORE

Agora o projeto em execução

Abaixo está o fonte do projeto, divirta-se :D

Marcadores: java, JDeveloper 11g

// postado por Cássio Sousa @ 23:20 0 Comentários Links para esta postagem

Estou utilizando autenticação mútua em um projeto e resolvi postar como fazer isso utilizando o Oracle Weblogic 10.3. Embora seja trabalhoso a configuração é bem simples.

Antes disso, o que é Autenticação mútua?

Autenticação mútua ou autenticação de duas vias é quando o cliente se autentica no servidor e o servidor se autentica com a aplicação cliente. Dessa forma a identidade dos dois se torna confiável. O cliente confia no servidor pois possui ele em sua base de confiança (trust store - servidor) e o servidor confia no cliente pelo mesmo motivo (trust store cliente). A autenticidade e a identidade do cliente e do servidor é feita utilizando certificados.

Nós vamos utilizar aqui o padrão X.509.

Mãos à obra.


Primeiro passo: Configurar o SSL simples:

1. Adicionar o CA de teste no browser (ou outro CA - Verisign, ICP-Brasil, ...).

O CA ou Certificate authority é a entidade autoridade de certificação. Ela é responsavél por dizer quando um certificado é confiável ou não. Ela normalmente emite certificados.

No firefox:
Ferramentas, Opções (ou Editar, Preferências), Avançado, Criptografia, Autoridades, Importar

No IE:
Ferramentas, Opções da Internet, Conteúdo, Certificados, Autoridades de Certificação Raiz Confiáveis, Importar

Para testes: utilizar o CA de teste localizado em:
\wlserver_10.3\server\lib\CertGenCA.der

e selecionar para confiar nesse CA.




2. Configurar o SSL no server.
No console do Weblogic, selecionar Environment, Servers e o seu server, General, habilitar SSL (SSL Listen Port Enabled), colocar uma porta SSL.

Para testes: selecionar Keystores, utilizar Demo Identity e Demo Trust aplicar as alterações.
Para produção: selecionar Keystores, utilizar Custom Identity e Custom Trust, configurar os dados do identity e do trust



Restartar o server.


3. Acessar uma página para verificar se o SSL simples está funcionando. Por exemplo:

https://localhost:7002/console




Segundo passo: Configurar o SSL de duas vias

1. Para testes, criar o certificado cliente ou em produção utilizar um já existente que seja confiável pelo servidor

Executar o setDomainEnv.cmd do domínio para setar as variáveis de ambiente.

Executar o CertGen

java utils.CertGen -certfile certfile.cer -keyfile keyfile.key -keyfilepass password -cn ThiagoVespa



2. Converter para um formato conhecido do browser

Alguns browsers não reconhecem o PEM/DER gerado então é necessária a conversão para PKCS

java utils.ImportPrivateKey -keystore ThiagoVespa.p12 -storepass password -storetype pkcs12 -keypass password -alias personal -certfile certfile.cer.pem -keyfile keyfile.key.pem -keyfilepass password


3. Carregar o certificado cliente no Browser ou utilizar algum dispositivo de segurança.

No Firefox:
Ferramentas, Opções (ou Editar, Preferências), Avançado, Criptografia, Certificados (ou Disp de segurança), Seus certificados, Importar o certificado com extensão p12.

No IE:
Ferramentas, Opções da Internet, Conteúdo, Certificados, Pessoal, Importar o certificado com extensão p12.



4. Configurar o servidor para requerer certificados do cliente

No console do weblogic, selecionar Environment, Servers e o seu server, SSL, Advanced, Alterar o Set Two Way Client Behavior para Client Certs Requested and Enforced, Aplicar alterações e reiniciar o servidor.




5. Accessar a página com o SSL de duas vias

Accessar por exemplo o console:

https://localhost:7002/console

E o browser deverá pedir a você o certificado criado.




Pronto, a autenticação mútua está funcionando.

Marcadores: java, weblogic

// postado por Thiago G. Vespa @ 03:08 0 Comentários Links para esta postagem

public static boolean isJSR77Available() {
 // Verifica se a JSR 75 está disponível
 return System
  .getProperty("microedition.io.file." +
    "FileConnection.version")
    != null;
}

public final static String FILE_SEPARATOR = (System
  .getProperty("file.separator") != null) ? System
  .getProperty("file.separator") : "/";

public final static String TOP_DIR = "..";
public final static String FILE_PREFIX = "file:///";

public static boolean isRoot(String path) {
 // Operação sobre o path ao invés de verificar na lista de roots
 // Verifica se o primeiro separador de arquivo é o último caractere
 if (path != null
   && path.indexOf(FileUtil.FILE_SEPARATOR) != path.length() - 1) {
  return false;
 }
 return true;
}

package br.com.thiagovespa.mobwiki.util;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Vector;

import javax.microedition.io.Connector;
import javax.microedition.io.file.FileConnection;

/**
 * Classe para manipulação de arquivos
 * 
 * @author Thiago Galbiatti Vespa
 * 
 */
public final class FileUtil {
 public final static String FILE_SEPARATOR = (System
   .getProperty("file.separator") != null) ? System
   .getProperty("file.separator") : "/";

 public final static String TOP_DIR = "..";
 public final static String FILE_PREFIX = "file:///";

 /**
  * Verifica se o caminho é uma raiz baseado na string passada, pode resultar
  * em resultado falso caso seja passada um caminho inválido
  * 
  * @param path
  *            caminho a ser verificado
  * @return verdadeiro se o formato da string for raiz
  */
 public static boolean isRoot(String path) {
  // Operação sobre o path ao invés de verificar na lista de roots
  // Verifica se o primeiro separador de arquivo é o último caractere
  if (path != null
    && path.indexOf(FileUtil.FILE_SEPARATOR) != path.length() - 1) {
   return false;
  }
  return true;
 }

 /**
  * Cria um diretório
  * 
  * @param path
  *            diretório a ser criado
  * @return true se o diretorio foi criado, false caso contrário
  */
 public static boolean createDir(String path) {
  FileConnection newDir = null;
  try {
   newDir = (FileConnection) Connector.open(FileUtil.FILE_PREFIX
     + path + FileUtil.FILE_SEPARATOR, Connector.READ_WRITE);
   if (!newDir.exists()) {
    newDir.mkdir();
    return true;
   } else {
    ExceptionHandler.handleException(new IOException(Language
      .getLocalizedString("dirAlreadyExist")));
   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   if (newDir != null) {
    try {
     newDir.close();
    } catch (IOException e) {
     ExceptionHandler.handleException(e);
    }
   }

  }
  return false;
 }

 /**
  * Cria um novo arquivo
  * 
  * @param path
  *            arquivo a ser criado
  * @return true se o arquivo foi criado, false caso contrário
  */
 public static boolean createNewFile(String path, String content) {
  FileConnection newFile = null;
  DataOutputStream dos = null;
  try {
   newFile = (FileConnection) Connector.open(FileUtil.FILE_PREFIX
     + path, Connector.READ_WRITE);
   if (!newFile.exists()) {
    newFile.create();
    dos = newFile.openDataOutputStream();
    dos.writeUTF(content);
    dos.flush();
    return true;
   } else {
    ExceptionHandler
      .handleException(new IOException(Language
        .getLocalizedString("file")
        + path
        + Language
          .getLocalizedString("already exists!")));
   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (newFile != null) {
     newFile.close();
    }
    if (dos != null) {
     dos.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return false;
 }

 /**
  * Atualiza arquivo
  * 
  * @param path
  *            arquivo a ser atualizado
  * @return true se o arquivo foi atualizado, false caso contrário
  */
 public static boolean updateFile(String path, String content) {
  FileConnection file = null;
  DataOutputStream dos = null;
  try {
   file = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ_WRITE);

   if (!file.exists()) {
    // Cria se não existe
    file.create();
   } else {
    // Trunca se já existe
    file.truncate(0);
   }
   dos = file.openDataOutputStream();
   dos.writeUTF(content);
   dos.flush();
   return true;

  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (file != null) {
     file.close();
    }
    if (dos != null) {
     dos.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return false;

 }

 public static boolean existsFile(String path) {
  FileConnection file = null;
  try {
   file = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ);
   if (file.exists()) {
    return true;

   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (file != null) {
     file.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return false;
 }

 /**
  * Lê um arquivo
  * 
  * @param path
  *            arquivo a ser lido
  * @return conteúdo do arquivo
  */
 public static String loadFile(String path) {
  FileConnection file = null;
  DataInputStream dis = null;
  String retVal = null;
  try {
   file = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ);
   if (file.exists()) {
    dis = file.openDataInputStream();
    retVal = dis.readUTF();

   } else {
    ExceptionHandler.handleException(new IOException("File " + path
      + " do not exists!"));
   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (file != null) {
     file.close();
    }
    if (dis != null) {
     dis.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return retVal;
 }

 /**
  * Lê um diretório
  * 
  * @param path
  *            diretório a ser lido
  * @return lista
  */
 public static String[] loadDir(String path, String pattern) {
  FileConnection dir = null;
  String[] retVal = null;
  Vector files = new Vector();
  try {
   dir = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ);
   if (dir.exists()) {
    Enumeration en = dir.list(pattern, true);
    while (en.hasMoreElements()) {
     String object = (String) en.nextElement();
     files.addElement(object);
    }
    if (files != null) {
     retVal = new String[files.size()];
     files.copyInto(retVal);
    }
   } else {
    ExceptionHandler.handleException(new IOException("File " + path
      + " do not exists!"));
   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (dir != null) {
     dir.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return retVal;
 }

 /**
  * Remove um diretório
  * 
  * @param path
  *            diretório a ser removido
  * @return true se removido e false caso contrário
  */
 public static boolean deleteDir(String path) {
  FileConnection dir = null;
  try {
   dir = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ_WRITE);
   if (dir.exists()) {
    Enumeration en = dir.list("*", true);
    while (en.hasMoreElements()) {
     String object = (String) en.nextElement();
     if (object.endsWith(FileUtil.FILE_SEPARATOR)) {
      deleteDir(path + object);
     } else {
      deleteFile(path + object);
     }

    }
    dir.delete();
    dir.close();
    return true;
   } else {
    ExceptionHandler.handleException(new IOException(Language
      .getLocalizedString("file")
      + path + Language.getLocalizedString("doNotExist")));

   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (dir != null) {
     dir.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return false;
 }

 /**
  * Remove um arquivo
  * 
  * @param path
  *            arquivo a ser removido
  * @return true se removido e false caso contrário
  */
 public static boolean deleteFile(String path) {
  FileConnection file = null;
  try {
   file = (FileConnection) Connector.open(FileUtil.FILE_PREFIX + path,
     Connector.READ_WRITE);
   if (file.exists()) {
    file.delete();
    file.close();
    return true;
   } else {
    ExceptionHandler.handleException(new IOException(Language
      .getLocalizedString("file")
      + path + Language.getLocalizedString("doNotExist")));

   }
  } catch (IOException e) {
   ExceptionHandler.handleException(e);
  } catch (SecurityException e) {
   ExceptionHandler.handleException(e, Language
     .getLocalizedString("securityExceptionDesc"));
  } finally {
   try {
    if (file != null) {
     file.close();
    }
   } catch (IOException e) {
    ExceptionHandler.handleException(e);
   }

  }
  return false;
 }

}

Marcadores: j2me, java, lwuit

// postado por Thiago G. Vespa @ 10:06 0 Comentários Links para esta postagem