RFWMetaAnnotations

As RFWMeta são Java Annotations oferecidas pelo FrameWork que permitem que os VOs tenham informações sobre sua própria definição (Meta Dados): da classe e dos atributos. Essas informações podem ser utilizadas posteriormente por várias partes do sistema, por exemplo:

• Podem ser utilizadas pela camada de persistência para saber como tratar os dados e inseri-los no banco de dados relacional;
• Por sistemas de validações automáticas;
• Por lógicas da camada de apresentação que sabem que campo criar, fazer o bind, e validar antes de abrir uma conexão com o Core.

RFWMetaField

Os metadados disponíveis para atributos recebem o seguinte padrão de nome: "RFWMeta" + <Tipo do Atributo> + <Nome Específico> + "Field". Sendo:

• Tipo do Atributo - É o tipo do java que define o atributo. Ex: String, Integer, BigDecimal, etc.
• Nome Específico - Essa parte só existe para alguns tipos de campos específicos. Por exemplo, para campos do tipo String que são usados como CNPJ a annotation RFWMetaStringCNPJField pode ser usada para indicar que o atributo é um CNPJ.

Os Meta Dados que podem ser definidos dependem do tipo do atributo. Por exemplo para atributos do tipo String é possível informar o maxlength e minlength, já para atributos numéricos é possível informar valores mínimos e máximos, e assim por diante.

Alguns metadados são comuns para todas os atributos, são eles:

• caption - Nome compreensível para o campo. Nome em português para o campo usado em mensagens de validação, na geração dos campos para a UI, etc. Embora não esteja sendo internacionalizado no momento, se em algum momento no futuro isso for necessário basta trocar os valores pelas chaves do Bundle e passar a resolve-las com o locale correto no momento do uso.
• required - Obrigatoriedade. Define se a definição deste atributo é obrigatório ou não.
• unique - Valor único entre os objetos existentes. Caso definido, indica que nenhuma outra instância do mesmo objeto terá o mesmo valor.

Alguns dos RFWMetaFields existentes são:

• RFWMetaStringField - Conjunto de MetaDados para String.
• RFWMetaIntegerField - Conjunto de MetaDados para Integer.
• RFWMetaBigDecimalField - Conjunto de MetaDados para BigDecimal.
• RFWMetaEnumField - Conjunto de MetaDados para Enumerations.
• RFWMetaBooleanField - Conjunto de MetaDados para Booleans.

As RFWMetaFields "personalizadas" permitem informar um uso específico para aquele atributo. Uma vez que o uso "personalizado" foi definido qualquer parte do sistema que leia as RFWMetaAnnotations saberá como tratar o campo a partir das informações específicas. Algumas RFWMetaFields para campos "personalizados" são:

• RFWMetaStringCNPJField - Transforma um atributo String em um atributo usado exclusivamente para CNPJ, já definindo tamanho máximo e mínimo, patterns, etc.
• RFWMetaStringCEPField - Transforma um atributo String em um atributo usado exclusivamente para CEP.
• RFWMetaStringPhoneField - Transforma um atributo String em um atributo para número de telefone no padrão do RFW: DDI|DDD|Telefone.

Exemplos de Uso

/** * Define o nome da categoria. */ @RFWMetaStringField(caption = "Nome da Categoria", maxlength = 100, minlength = 3, required = true) private String name = null; /** * Define se o tipo desta categoria. */ @RFWMetaEnumField(caption = "Tipo da Categoria", required = true) private CategoryType categoryType = null; /** * Define um markup mínimo para a categoria. */ @RFWMetaBigDecimalField(caption = "MarkUp Mínimo", minIntegerValue = 0) private BigDecimal minMarkUp = null;

RFWMetaRelationshipField

A RFWMetaRelationshipField é uma annotation especial para atributos a fim de declarar o relacionamento entre objetos. O relacionamento suportado é apenas entre RFWVO. Esta annotation atualmente não suporta o relacionamento com outros tipos de objetos. No entanto, suporta relacionamento dentro de Listas e Hashs.

O relacionamento pode ser definido de dois tipos:

• COMPOSITION - O Relacionamento de composição indica que o objeto sendo associado é um "sub conjunto" de informações deste objeto. No sentido que o objeto do relacionamento não existe sem este objeto. Quando este objeto for excluído ele deve ser excluído também! Afinal, ele é parte do objeto principal.
• ASSOCIATION - A associação indica apenas um relacionamento entre dois objetos "distintos". Cada objeto tem sua própria existência independente da existência do outro. A exclusão de um não implica na exclusão do outro. Nesse tipo de relacionamento o objeto associado já existe no banco de dados previamente, não é cadastrado nem excluído em cascata.

	Exemplos de Associação
	/** * Empresa associada. */ @RFWMetaRelationshipField(caption = "Empresa", relationship = RelationshipTypes.ASSOCIATION, required = true) private CompanyVO companyvo = null;

Exemplos de Composição

/** * Guarda as configurações de cada empresa da categoria de itens.<br> * A chave é o ID da empresa, e o valor é o objeto com as configurações (<code>ItemCategoryCompanyVO</code>). */ @RFWMetaRelationshipField(caption = "Definições por Empresa", relationship = RelationshipTypes.COMPOSITION, required = true, moclazz = ItemCategoryCompanyMO.class) private List<ItemCategoryCompanyVO> itemcategorycompanylist = null;

RFWMetaCollectionField

Esta meta annotation tem a finalidade de definir os parâmetros de uma coleção de valores. Uma coleção de valores é quando um atributo tem uma Collection (List, Set, etc.) de valores, por exemplo:

	Exemplos de Collection
	@RFWMetaCollectionField(caption = "Tags", column = "tag", fkColumn = "idk_logger", required = false, targetRelationship = String.class, table = "k_loggertags") public HashSet<String> tags = null;

RFWMetaEncrypt

Esta annotation tem muita utilidade quando pensamos na persistência do valor. Ela indica que o conteúdo deste objeto, quando persistido deve ser ter o seu conteúdo criptografado para que não fique exposto diretamente no banco de dados, arquivo, etc.

Aceita o atributo key que pode ser utilizado como a chave de criptografia diretamente, caso o sistema de persistência já tenha sua metodologia segura para criptografar e descriptografar a informação

	Exemplos de Criptografia de Senha
	@RFWMetaStringField(caption = "Senha", maxlength = 255, required = true) @RFWMetaEncrypt(key = "32OR09mQLdcG1RjeMGxEWF4sZRUkxZQstxki7J8ri3fl") private String password = null;

RFWMetaGenericField

Esta annotation foi criada para permitir algum tipo de identificação em objetos não suportados pelas outras tags de fields comums. Pode ser utilizada por exemplo quando o objeto salvo no RFWVO é uma interface e sua instância é de uma classe diferente a cada momento.

Ao utilizar esse tipo de ligação as automações de RFW ficam mais limitadas, mas pode ser útil em muitos casos.

Um exemplo é a utilização com a interface MeasureUnit do serviço RFWMeasure:

	Exemplo de utilização do RFWMetaGenericField
	@RFWDAOConverter(converterClass = MeasureUnitDAOConverter.class) @RFWMetaGenericField(caption = "Fator Unidade Medida Item", required = false) private MeasureUnit ratioItemMeasure = null;

RFW Constraints

RFWContraints são um grupo de annotations à nível de classe, para a definição de meta dados da entidade/VO, não apenas do atributo.

RFWMetaAttributeRelation

Esta Annotation permite definir a relação entre dois atributos do vo, podendo mesmo ser um atributo em cadeia (dentro de outro objeto). É possível definir uma operação de comparação entre os atributos. Por exemplo, dois atributos devem ser iguais, dois atributos devem ser diferentes, um atributo deve ser maior que o outro e assim por diante.

É possível ainda indicar o próprio código de erro para o caso da relação não ser respeitada.

	Exemplos de Relação entre Atributos
	@RFWMetaAttributeRelation(attribute = ItemVO_._markup, attribute2 = ItemVO_._markupMin, operation = COMPAREOPERATION.MORETHAN, exceptioncode = "RFWModules_000317")

RFWMetaUniqueConstraint

Esta annotation permite indicar um conjunto de atributos do VO que devem ser únicas. Similar ao UniqueConstraint do Banco de Dados, através desta annotation é possível indicar um conjunto de atributos e indicar que o conjunto todo não deve se repetir em nenhuma outra instância do objeto.

	Exemplos de Unicidade em Conjunto de Atributos
	@RFWMetaUniqueConstraint(fields = { ItemVO._name, ItemVO_._parentitemcategoryvo + "." + ItemCategoryVO_._id })

RFWMetaUsedBy & RFWMetaDependency

Estas duas annotations funcionam em conjunto, embora representem o oposto.

A RFWMetaUsedBy tem a finalidade de indicar que esta entidade é usada por outra, isto é, alguma instância desta entidade pode estar atualmente em uso por outra entidade. Quando uma instância está atualmente em uso ela não poderá ser excluída. A referência do RFWMetaUsedBy pode não ser sempre possível uma vez que o objeto pode ser utilizado por uma entidade de outro módulo/Plugin "desconhecido". Nestes casos ela não deve ser feita. Quando feita, é necessário passar dois parâmetros:

• voclazz Classe da entidade que depende desta classe.

Ao declarar a RFWMetaUserBy é obrigatório que a classe com a dependência tenha a annotation RFWMetaDependency. Essa annotation tem a finalidade de indicar "como" uma entidade depende da outra. A RFWMetaDependency tem dois atributos:

• voclass - que indica a classe da qual ela depende.
• attribute - atributo que cria a dependência com a outra classe.

Note que a Classe que tem a RFWMetaUsedBy referencia o VO da classe que depende desta. Por sua vez, a classe dependente deve ter a Annotation RFWMetaependency referenciando a entidade da qual depende. Abaixo um exemplo das classes ItemCategoryVO e ItemTypeVO, sendo que ItemTypeVO depende da ItemCategoryVO:

	Exemplo de RFWMetaUsedBy e RFWMetaDependency
	@RFWMetaUsedBy(voclazz = ItemTypeVO.class) public class ItemCategoryVO extends RFWVO { ... } @RFWMetaDependency(voclazz = ItemCategoryVO.class, attribute = "itemcategorylist") public class ItemTypeVO extends RFWVO { ... }

Também é possível usar as annotations para indicar um relacionamento de dependência dentro da mesma entidade, como entidades hierarquicas. Cuja instância depende de outra instância da mesma entidade. Neste caso definimos ambas as annotations na mesma classe.

	Exemplo de RFWMetaUsedBy e RFWMetaDependency em dependência cíclica
	@RFWMetaUsedBy(voclazz = ItemCategoryVO.class) @RFWMetaDependency(voclazz = ItemCategoryVO.class, attribute = "parentitemcategoryvo") public class ItemCategoryVO extends RFWVO { ... }

RFWMetaDependency não obriga RFWMetaUsedBy Embora toda vez que seja usada a annotation RFWMetaUsedBy em uma classe torne-se obrigatório o uso de RFWMetaDependency, o contrário não é necessário. Caso uma entidade declare dependência de outra (usar a RFWMetaDependency) não obriga que a outra classe utilize a RFWMetaUsedBy. Isso porque a classe que depende de outra obviamente conhece a classe da qual depende. Por outro lado, a classe que é "usada por" outra, não necessariamente a conhece, pois pode estar em outro projeto, módulo, plugin, etc.