openxava / documentation / Model

Business Component

• Model: Data structure, validations, calculations, etc.
• View: How the model can be shown to the user.
• Tabular data: How the data of the component is displayed in list mode (in tabular format).
• Object/relational mapping: How to store and retrieve the object state from database.

Entity

@Entity // 1
@EntityValidator // 2
@RemoveValidator // 3
public class EntityName { // 4
 // Properties // 5
 // References // 6
 // Collections // 7
 // Methods // 8
 // Finders // 9
 // Callback methods // 10
}

1. @Entity (JPA, one, required): Indicates that this class is a JPA entity, in other words, its instances will be persistent objects.
2. @EntityValidator (OX, several, optional): Executes a validation at model level. This validator can receive the value of various model properties. To validate a single property it is better to use a property level validator.
3. @RemoveValidator (OX, several, optional): It's executed before removal, and can deny the object removing.
4. Class declaration: As a regular Java class. You can use extends and implements.
5. Properties: Regular Java properties. They represent the main state of the object.
6. References: References to other entities or embeddable classes.
7. Collections: Collections of references to other entities or embeddable classes.
8. Methods: Java methods with the business logic.
9. Finders: Finder methods are static method that do searches using JPA query facilities.
10. Callback methods: JPA callbacks methods to insert logic on creating, modifying, loading, removing, etc.

Embeddable classes

@Embeddable // 1
public class EmbeddableName { // 2
 // Properties // 3
 // References // 4
 // Methods // 5
}
 

1. @Embeddable (JPA, one, required): Indicates that this class is an embeddable class of JPA, in other words, its instances will be part of persistent objects.
2. Class declaration: As a regular Java class. You can use extends and implements.
3. Properties: Regular Java properties.
4. References: References to entities or embeddable classes.
5. Methods: Java methods with the business logic.

Properties

@Stereotype                                                                //  1
@Column(length=) @Column(precision=) @Max @Length(max=) @Digits(integer=)  //  2
@Digits(integer=) @Digits(fraction=)                                       //  3
@Required @Min @Range(min=) @Length(min=)                                  //  4
@Id                                                                        //  5
@Hidden                                                                    //  6
@SearchKey                                                                 //  7
@Version                                                                   //  8
@Formula                                                                   //  9  New in v3.1.4
@Calculation                                                               // 10  New in v5.7
@DefaultValueCalculator                                                    // 11
@PropertyValidator                                                         // 12
private type propertyName;                                                 // 13
public type getPropertyName() { ... }                                      // 13
public void setPropertyName(type newValue) { ... }                         // 13
 

1. @Stereotype (OX, optional): Allows to specify a special behavior for some properties.
2. @Column(length=) (JPA), @Max (BV), @Length(max=) (HV), @Digits(integer=) (BV) (optional, usually you only use one of them): Length in characters of property, except in @Max case that is the max value. Useful to generate user interfaces. If you do not specify the size then a default value is assumed. This default value is associated to the stereotype or type and it's obtained from default-size.xml. @Max and @Digits are from Bean Validation (new in v4.1) or Hibernate Validator (until v5.2.x).
3. @Column(scale=) (JPA), @Digits(fraction=) (BV): Scale (size of decimal part) of property. Only applies to numeric properties. If you do not use @Column or @Digits a default value is assumed, if you use @Column without length, without precision and without scale a default value is assumed for scale, if you use @Column with length or precision and without scale a 0 is assumed for scale (new in v7.0.6 before a default value was assumed), if you use @Digits without fraction, 0 is assumed. The default value is associated to the stereotype or type and is obtained from default-size.xml. @Digits is from Bean Validation (new in v4.1) or Hibernate Validator (until v5.2.x).
4. @Required (OX), @Min (BV), @Range(min=) (HV), @Length(min=) (HV) (optional, usually you only use one of them): Indicates if this property is required. In the case of @Min, @Range and @Length you have to put a value greater than zero for min in order to assume that the property is required. By default a property is required for key properties hidden (new in v2.1.3) and false in all the other cases. On saving OpenXava verifies if the required properties are present. If this is not the case, then the saving is not done and a validation error list is returned. The logic to determine if a property is present or not can be configured by creating a file called validators.xml in your project. You can see the syntax in openxava/src/main/resources/xava/default-validators.xml. @Required and @Min are Bean Validation constraints since v5.3 and they were Hibernate Validator constraints until v5.2.x.
5. @Id (JPA, optional): Indicates that this property is part of the key. At least one property (or reference) must be key. The combination of key properties (and key references) must be mapped to a group of database columns that do not have duplicate values, typically the primary key.
6. @Hidden (OX, optional): A hidden property has a meaning for the developer but not for the user. The hidden properties are excluded when the automatic user interface is generated. However at Java code level they are present and fully functional. Even if you put it explicitly into a view the property will be shown in the user interface.
7. @SearchKey (OX, optional): The search key properties are used by the user as key for searching objects. They are editable in user interface of references allowing to the user type its value for searching. OpenXava uses the @Id properties for searching by default, and if the id properties are hidden then it uses the first property in the view. With @SearchKey you can choose explicitly the properties for searching.
8. @Version (JPA, optional): A version property is used for optimistic concurrency control. If you want control concurrency you only need to have a property marked as @Version in your entity. Only a single version property should be used per entity. The following types are supported for version properties: int, Integer, short, Short, long, Long, Timestamp. The version properties are considered hidden.
9. @Formula (HA, optional): (New in v3.1.4) To calculate the value of the property using the database. It must be a valid SQL fragment.
10. @Calculation (OX, one, optional): (New in v5.7) Arithmetic expression to do the calculation for the property. The calculation is done in the user interface when any operand changes.
11. @DefaultValueCalculator (OX, one, optional): Implements the logic to calculate the default (initial) value for this property. A property with @DefaultValueCalculator has setter and it is persistent.
12. @PropertyValidator (OX, several, optional): Implements the validation logic to execute on this property before modifying or creating the object that contains it.
13. Property declaration: A regular Java property declaration with its getters and setters. You can create a calculated property using only a getter with no field nor setter. Any type legal for JPA is available, you only need to provide a Hibernate Type to allow saving in database and an OpenXava editor to render as HTML.

Stereotype

• @Money (new in v6.6), MONEY, DINERO
• PHOTO, IMAGEN, FOTO, IMAGE (since v6.6 you can use @File as alternative that is more flexible and performant)
• @TextArea (new in v6.6), MEMO, TEXT_AREA, TEXTO_GRANDE
• @Label (new in v6.6), LABEL, ETIQUETA
• BOLD_LABEL, ETIQUETA_NEGRITA
• @StringTime (new in v6.6), TIME, HORA (since v7.3 you can use LocalTime type property instead of String. It has a more sophisticated editor and maps to a TIME type data in the database)
• @DateTime (new in v6.6), DATETIME, FECHAHORA (since v7.4 you can use LocalDateTime type property instead of Date with @DateTime/Stereotype("DATETIME"))
• IMAGES_GALLERY, GALERIA_IMAGENES (setup instructions) (since v6.6 you can use @Files as alternative)
• @ZerosFilled (new in v7.1), ZEROS_FILLED, RELLENADO_CON_CEROS
• @HtmlText (new in v6.6), HTML_TEXT, TEXTO_HTML (text with editable format)
• @HtmlText(simple=true) (new in v6.6), SIMPLE_HTML_TEXT, TEXTO_HTML_SIMPLE (new in v5.6, like HTML_TEXT with a simplified UI)
• IMAGE_LABEL, ETIQUETA_IMAGEN (image depending on property content)
• @Email (from javax.validation.constraints) (new in v6.6), EMAIL
• @Telephone (new in v6.6), TELEPHONE, TELEFONO
• @URL (from org.hibernate.validator.constraints) (new in v6.6), WEBURL
• @IP (new in v6.6), IP
• @ISBN (from org.hibernate.validator.constraints) (new in v6.6), ISBN
• @CreditCardNumber (from org.hibernate.validator.constraints) (new in v6.6), CREDIT_CARD, TARJETA_CREDITO
• @EmailList (new in v6.6), EMAIL_LIST, LISTA_EMAIL
• DOCUMENT_LIBRARY, LIBRERIA_DOCUMENTOS (new in v4m6, until v6.6.3, it only works inside Liferay)
• @Password (new in v6.6), PASSWORD, CONTRASENA (new in v4.1)
• @MAC (new in v6.6), MAC (new in v4.8)
• @File (new in v6.6), FILE, ARCHIVO (new in v5.0) (setup instructions)
• @Files (new in v6.6), FILES, ARCHIVOS (new in v5.1) (setup instructions)
• @Icon (new in v6.6), ICON, ICONO (new in v5.5)
• @Discussion (new in v6.6), DISCUSSION, DISCUSION (new in v5.6) (setup instructions)
• @Coordinates, COORDINATES, COORDENADAS (new in v6.6) (setup instructions)
• @HandwrittenSignature, HANDWRITTEN_SIGNATURE, FIRMA_MANUSCRITA (new in v7.6) (setup instructions)

<editor url="personNameEditor.jsp">
    <for-stereotype stereotype="PERSON_NAME"/>
    <for-annotation annotation="com.yourcompany.yourapp.annotations.PersonName"/> <!-- New in v6.6 -->
</editor>

<for-stereotype name="PERSON_NAME" size="40"/>
<for-annotation class="com.yourcompany.yourapp.annotations.PersonName" size="40"/> <!-- New in v6.6 -->

<required-validator>
    <validator-class class="org.openxava.validators.NotBlankCharacterValidator"/>
    <for-stereotype stereotype="PERSON_NAME"/>
    <for-annotation annotation="com.yourcompany.yourapp.annotations.PersonName"/> <!-- New in v6.6 -->
</required-validator>

@Stereotype("PERSON_NAME")
private String name;

@PersonName
private String name;

IMAGES_GALLERY stereotype

@Stereotype("IMAGES_GALLERY")
private String photos;

CREATE TABLE IMAGES (
 ID VARCHAR(32) NOT NULL PRIMARY KEY,
 GALLERY VARCHAR(32) NOT NULL,
 IMAGE BLOB);
CREATE INDEX IMAGES01
 ON IMAGES (GALLERY);

<persistence-unit name="default">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <non-jta-data-source>java:comp/env/jdbc/OpenXavaTestDS</non-jta-data-source>
 <class>org.openxava.session.GalleryImage</class> <!-- ADD THIS LINE -->
 <class>org.openxava.web.editors.DiscussionComment</class> 
  ...
</persistence-unit>
 

<hibernate-configuration>
 <session-factory>
 ...
 <mapping resource="GalleryImage.hbm.xml"/>
 ...
 </session-factory>
</hibernate-configuration>

File (new in v5.0) and Files (new in v5.1)

@File
@Column(length=32)
private String document;

@Stereotype("FILE")
@Column(length=32)
private String document;

@Files
@Column(length=32)
private String documents;

@Stereotype("FILES")
@Column(length=32)
private String documents;

@File(acceptFileTypes="image/*", maxFileSizeInKb=90)
@Column(length=32)
private String photo;

@Files(acceptFileTypes="text/csv, application/vnd.ms-excel, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
@Column(length=32)
private String spreadsheets;

Storage in File System

Storage in Database

• Set the filePersistorClass property in xava.properties

filePersistorClass=org.openxava.web.editors.JPAFilePersistor
...

• Modify the persistence.xml

<persistence-unit name="default">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <non-jta-data-source>java:comp/env/jdbc/OpenXavaTestDS</non-jta-data-source>
 <class>org.openxava.session.GalleryImage</class>
 <class>org.openxava.web.editors.AttachedFile</class>
  ...
</persistence-unit>
 
        ...
 
<persistence-unit name="junit">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <class>org.openxava.web.editors.AttachedFile</class>
 ....
</persistence-unit>

• When the database is generated, the table OXFILES is created:

CREATE TABLE OXFILES (
 ID VARCHAR(32) NOT NULL PRIMARY KEY,
 NAME VARCHAR(255),
 DATA LONGVARBINARY,
 LIBRARYID VARCHAR(32)
);

Manage files programmatically

Properties annotated with @File, @Files, @HandwrittenSignature, Stereotype("FILE"), @Stereotype("FILES") or @Stereotype("HANDWRITTEN_SIGNATURE") only store a 32-character identifier, not the file content. To access the content of the uploaded file from your own code, you need to use an IFilePersistor obtained from FilePersistorFactory, classes that you can find in the org.openxava.web.editors package. These classes work the same regardless of whether the files are stored in the file system, a database, or any other location.

In the case of @File, @HandwrittenSignature, @Stereotype("FILE") or @Stereotype("HANDWRITTEN_SIGNATURE"), the property directly stores the file ID. For example, if we have a property like this:

@File @Column(length=32)
String photo;

We can fill it with a file using our own code like this:

import java.nio.file.*;

import org.openxava.actions.*;
import org.openxava.web.editors.*;

public class LoadPhotoAction extends ViewBaseAction {

    public void execute() throws Exception {
        // In this example we get the file from filesystem
        // but in your case you could get the file from any other place
        String filePath = "/home/me/images/myphoto.png";
        byte[] fileBytes = Files.readAllBytes(Paths.get(filePath));

        // An IFilePersistor to work with the file 
        IFilePersistor filePersistor = FilePersistorFactory.getInstance();

        // We create an AttachedFile object 
        AttachedFile file = new AttachedFile();
        file.setName("myphoto.png");
        file.setData(fileBytes);
		
        // This save the file 
        filePersistor.save(file);
		
        // After saved, the AttachedFile has its id populated
        // so we set it to the property in the view
        getView().setValue("photo", file.getId());
    }

}

You create an AttachedFile and save it with an IFilePersistor, then obtain the file ID to use it as the value for the property. The photo property stores the file ID.

The reverse process, that is, obtaining and manipulating the file already in the @File property, would be like this:

import java.nio.file.*;

import org.openxava.actions.*;
import org.openxava.web.editors.*;

public class SavePhotoAction extends ViewBaseAction {

    public void execute() throws Exception {
        // An IFilePersistor to work with the file
        IFilePersistor filePersistor = FilePersistorFactory.getInstance();
		
        // We get the photo id from the property
        String photoId = getView().getValueString("photo");
		
        // And find the AttachedFile with that id using the IFilePersistor
        AttachedFile file = filePersistor.find(photoId);
		
        // We get the name and the content from the AttachedFile
        String fileName = file.getName();
        byte[] fileBytes = file.getData();
		
        // In this example we save the file in the filesystem
        // but you could do anything you want with the file
        String filePath = "/home/me/images/" + fileName;
        Files.write(Paths.get(filePath), fileBytes);
    }

}

You search for an AttachedFile using an IFilePersistor based on the photo ID you have in the property.

Working with @Files or @Stereotype(“FILES”) is slightly different because, in this case, the property stores the library ID, not the file ID. A library is a group of files. Each file has its own ID, but they all share a common library ID. For example, with a property like this:

@Files @Column(length=32)
String documents;

We can populate it with multiple files using our own code like this:

import java.nio.file.*;

import org.openxava.actions.*;
import org.openxava.web.editors.*;

public class LoadDocumentsAction 
    extends GenerateIdForPropertyBaseAction { // To use the generateIdForProperty() method

    public void execute() throws Exception {
        // In this example we're going to upload some files from the filesystem
        // but you could get the files or files content from any other place
        String basePath = "/home/me/documents/";
        String [] fileNames = {
            "limiting-data-by-user.pdf",
            "quick-start.odg"
        };

        // We need generate an id for the library first time or use the one
        // that already exists. This work is done for you by generateIdForProperty()
        // The generated id is left in the 'documents' property in the view
        String libraryId = generateIdForProperty("documents"); 
		
        // An IFilePersistor to work with the files
        IFilePersistor filePersistor = FilePersistorFactory.getInstance();
        for (String fileName: fileNames) {
            // For our example we get the file content from filesystem
            byte[] fileBytes = Files.readAllBytes(Paths.get(basePath + fileName));
			
            // We create an AttachedFile and fill it
            AttachedFile file = new AttachedFile();
            file.setLibraryId(libraryId); // The same libraryId for all files
            file.setName(fileName);
            file.setData(fileBytes);
			
            // Then save it using the IFilePersistor
            filePersistor.save(file);
        }
    }

}

The trick is that we need to have a single library ID to assign to each of the files we are going to save. This ID is generated with generateIdForProperty(), which creates it if it doesn’t exist or returns it if it already does. If a new one is generated, it is assigned to the property in the view, so when the entity is saved, it will be saved with the correct library ID. The rest is simply a loop creating AttachedFile and saving them with IFilePersistor, assigning each one the same library ID.

The opposite process, that is, retrieving and manipulating the files that are already in the @Files property, would be like this:

import java.nio.file.*;
import java.util.*;

import org.openxava.actions.*;
import org.openxava.web.editors.*;

public class SaveDocumentsAction extends ViewBaseAction {

    public void execute() throws Exception {
        // An IFilePersistor to work with the files
        IFilePersistor filePersistor = FilePersistorFactory.getInstance();
		
        // For @Files the property stores the library id, not any file id
        String libraryId = getView().getValueString("documents");
		
        // We use findLibrary() of IFilePersistor to get a collection of files
        Collection<AttachedFile> files =filePersistor.findLibrary(libraryId);
        for (AttachedFile file: files) {
            // We get the name and content from the AttachedFile
            String fileName = file.getName();
            byte[] fileBytes = file.getData();
            String filePath = "/home/me/documents/" + fileName;
			
            // In our example we save in the filesystem, 
            // but in your case you can do whatever you want
            Files.write(Paths.get(filePath), fileBytes);
        }
    }

}

Remember that for @Files in the property, the library ID is stored, not the file ID. From this ID, we use the findLibrary() method of IFilePersistor to get all the files associated with that library, i.e., that property. Then we loop through those files and process them as desired.

Discussion (new in v5.6)

@Discussion
@Column(length=32)
private String discussion;

@Stereotype("DISCUSSION")
@Column(length=32)
private String discussion;

@PreRemove
private void removeDiscussion() {
    DiscussionComment.removeForDiscussion(discussion);
}

<persistence-unit name="default">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <non-jta-data-source>java:comp/env/jdbc/OpenXavaTestDS</non-jta-data-source>
 <class>org.openxava.session.GalleryImage</class>
 <class>org.openxava.web.editors.DiscussionComment</class> <!-- ADD THIS LINE -->
  ...
</persistence-unit>
 

CREATE TABLE OXDISCUSSIONCOMMENTS (
    ID VARCHAR(32) NOT NULL,
    COMMENT CLOB(16777216),
    DISCUSSIONID VARCHAR(32),
    TIME TIMESTAMP,
    USERNAME VARCHAR(30),
    PRIMARY KEY (ID)
);
 
CREATE INDEX OXDISCUSSIONCOMMENTS_DISCUSSIONID_INDEX
    ON OXDISCUSSIONCOMMENTS (DISCUSSIONID);

Coordinates (new in v6.6)

@Coordinates @Column(length=50)
private String location;

# OpenTopoMap 
mapsTileProvider=https://b.tile.opentopomap.org/{z}/{x}/{y}.png
mapsAttribution=Map data © <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, Imagery © <a href="https://opentopomap.org">OpenTopoMap</a> (<a href="https://creativecommons.org/licenses/by-sa/3.0/">CC-BY-SA</a>)

# MapBox 
# Change below YOUR_ACCESS_TOKEN by your own access token
mapsTileProvider=https://api.mapbox.com/styles/v1/mapbox/streets-v11/tiles/{z}/{x}/{y}?access_token=YOUR_ACCESS_TOKEN
mapsAttribution=Map data © <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, Imagery © <a href="https://www.mapbox.com/">Mapbox</a>
mapsTileSize=512
mapsZoomOffset=-1

@View(members=
    "city [ state; "
        + "stateCondition;"
        + "code;"
        + "name;"
        + "population;"
        + "zipCode;"
        + "county;"
        + "country;"
        + "settled;"
        + "area;"
        + "elevation;"
        + "governmentType;"
        + "mayor;"
    + "], "
    + "location")

Handwritten signature (new in v7.6)

To allow the user to sign by hand and save their signature in a property, you have to annotate the property with @HandwrittenSignature or @Stereotype("HANDWRITTEN_SIGNATURE"):

import com.openxava.annotations.*; // Not org.openxava.annotations.*

...

@HandwrittenSignature
@Column(length=32)  
private String customerSignature;

Note how the annotation is in the package com.openxava.annotations (from XavaPro) and not in org.openxava.annotations.

The property would be displayed like this:

The user will be able to sign with their finger or a stylus for touch screens, especially designed for mobile phones and tablets, although it is also possible to sign using the mouse.

The property type is a String of 32 characters where an id is stored, not the signature itself. Signatures can be stored in the file system or in the database, using the same mechanism (the same filePersistorClass) as @File and @Files. It is also possible to manipulate signatures programmatically with FilePersistorFactory as with @File and @Files.

Mask (new in v7.1)

• 'L': the user must enter an alphabetical letter from A ~ z.
• '0': the user must enter a digit.
• 'A': the user must enter an alphanumeric character.
• '#': the user must enter a digit, blank space, '+' or '-'.

@Mask("L-000000")
private String passport;

@Mask("0000 0000 0000 0000")
private String creditCard;

@Mask("LL 000 AA")
private String carPlate;

@Mask("0.000/0-000")
private String customMask;

Concurrency and version property

@Version
private Integer version;

Enums

private Distance distance;
public enum Distance { LOCAL, NATIONAL, INTERNATIONAL };
 

Enums with icon (new in v6.3)

public enum Priority implements IIconEnum { 

	LOW("transfer-down"), MEDIUM("square-medium"), HIGH("transfer-up");

	private String icon;

	private Priority(String icon) {
		this.icon = icon;
	}

	public String getIcon() {
		return icon;
	} 
		
};
private Priority priority;

Calculated properties

@Depends("unitPrice") // 1
@Max(9999999999L) // 2
public BigDecimal getUnitPriceInPesetas() {
 if (unitPrice == null) return null;
 return unitPrice.multiply(new BigDecimal("166.386")).setScale(0, BigDecimal.ROUND_HALF_UP);
}
 

Product product = ...
product.setUnitPrice(2);
BigDecimal result = product.getUnitPriceInPesetas();
 

@Max(999)
public int getDetailsCount() {
 // An example of using JDBC
 Connection con = null;
 try {
 con = DataSourceConnectionProvider.getByComponent("Invoice").getConnection(); // 1
 String table = MetaModel.get("InvoiceDetail").getMapping().getTable();
 PreparedStatement ps = con.prepareStatement("select count(*) from " + table +
 " where INVOICE_YEAR = ? and INVOICE_NUMBER = ?");
 ps.setInt(1, getYear());
 ps.setInt(2, getNumber());
 ResultSet rs = ps.executeQuery();
 rs.next();
 Integer result = new Integer(rs.getInt(1));
 ps.close();
 return result;
 }
 catch (Exception ex) {
 log.error("Problem calculating details count of an Invoice", ex);
 // You can throw any runtime exception here
 throw new SystemException(ex);
 }
 finally {
 try {
 con.close();
 }
 catch (Exception ex) {
 }
 }
}
 

private long number;
 
@Id @Column(length=10) // You annotated the getter,
public long getNumber() { // so JPA will use property-base access for your class
 return number;
}
public void setNumber(long number) {
 this.number = number;
}
 
@Transient // You have to annotate as Transient your calculated property
public String getZoneOne() { // because you are using property-based access
 return "In ZONE 1";
}
 

Formula (new in v3.1.4)

@org.hibernate.annotations.Formula("UNITPRICE * 1.16")
private BigDecimal unitPriceWithTax;
public BigDecimal getUnitPriceWithTax() {
 return unitPriceWithTax;
}

Default value calculator

@DefaultValueCalculator(CurrentYearCalculator.class)
private int year;
 

package org.openxava.calculators;
 
import java.util.*;
 
/**
 * @author Javier Paniza
 */
public class CurrentYearCalculator implements ICalculator {
 
 public Object calculate() throws Exception {
 Calendar cal = Calendar.getInstance();
 cal.setTime(new java.util.Date());
 return new Integer(cal.get(Calendar.YEAR));
 }
 
}
 

@DefaultValueCalculator(
 value=org.openxava.calculators.StringCalculator.class,
 properties={ @PropertyValue(name="string", value="GOOD") }
)
private String relationWithSeller;

@DefaultValueCalculator(
 value=org.openxava.test.calculators.CarrierRemarksCalculator.class,
 properties={
 @PropertyValue(name="drivingLicenceType", from="drivingLicence.type")
 }
)
private String remarks;

@DefaultValueCalculator(value=DefaultProductPriceCalculator.class, properties=
 @PropertyValue(name="familyNumber")
)

@DefaultValueCalculator(value=DetailsCountCalculator.class,
 properties= {
 @PropertyValue(name="year"),
 @PropertyValue(name="number"),
 }
)
private int detailsCount;
 

package org.openxava.test.calculators;
 
import java.sql.*;
 
import org.openxava.calculators.*;
import org.openxava.util.*;
 
/**
 * @author Javier Paniza
 */
public class DetailsCountCalculator implements IJDBCCalculator { // 1
 
 private IConnectionProvider provider;
 private int year;
 private int number;
 
 public void setConnectionProvider(IConnectionProvider provider) { // 2
 this.provider = provider;
 }
 
 public Object calculate() throws Exception {
 Connection con = provider.getConnection();
 try {
 PreparedStatement ps = con.prepareStatement(
 "select count(*) from XAVATEST.INVOICEDETAIL “ +
 “where INVOICE_YEAR = ? and INVOICE_NUMBER = ?");
 ps.setInt(1, getYear());
 ps.setInt(2, getNumber());
 ResultSet rs = ps.executeQuery();
 rs.next();
 Integer result = new Integer(rs.getInt(1));
 ps.close();
 return result;
 }
 finally {
 con.close();
 }
 }
 
 public int getYear() {
 return year;
 }
 
 public int getNumber() {
 return number;
 }
 
 public void setYear(int year) {
 this.year = year;
 }
 
 public void setNumber(int number) {
 this.number = number;
 }
 
}

Default values on create

@Id @Hidden
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
 

@SequenceGenerator(name="SIZE_SEQ", sequenceName="SIZE_ID_SEQ", allocationSize=1 )
@Hidden @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SIZE_SEQ")
private Integer id;
 

@Id @GeneratedValue(generator="system-uuid") @Hidden
@GenericGenerator(name="system-uuid", strategy = "uuid")
private String oid;
 

@PrePersist
private void calculateCounter() {
 counter = new Long(System.currentTimeMillis()).intValue();
}
 

Property validator

@PropertyValidator(value=ExcludeStringValidator.class, properties=
    @PropertyValue(name="string", value="MOTO")
)
@PropertyValidator(value=ExcludeStringValidator.class, properties=
    @PropertyValue(name="string", value="COCHE"),
    onlyOnCreate=true
)
private String description;
 

@PropertyValidators ({ // Only needed until v6.0.2
   @PropertyValidator(value=ExcludeStringValidator.class, properties=
       @PropertyValue(name="string", value="MOTO")
   ),
   @PropertyValidator(value=ExcludeStringValidator.class, properties=
       @PropertyValue(name="string", value="COCHE"),
       onlyOnCreate=true
   )
})
private String description;

package org.openxava.test.validators;
 
import org.openxava.util.*;
import org.openxava.validators.*;
 
/**
 * @author Javier Paniza
 */
 
public class ExcludeStringValidator implements IPropertyValidator { // 1
 
 private String string;
 
 public void validate(
 Messages errors, // 2
 Object value, // 3
 String objectName, // 4
 String propertyName) // 5
 throws Exception {
 if (value==null) return;
 if (value.toString().indexOf(getString()) >= 0) {
 errors.add("exclude_string", propertyName, objectName, getString());
 }
 }
 
 public String getString() {
 return string==null?"":string;
 }
 
 public void setString(String string) {
 this.string = string;
 }
 
}

1. Messages errors: An object of type Messages that represents a set of messages (like a smart collection) and where you can add the validation errors that you find.
2. Object value: The value to validate.
3. String objectName: Object name of the container of the property to validate. Useful to use in error messages.
4. String propertyName: Name of the property to validate. Useful to use in error messages.

exclude_string={0} cannot contain {2} in {1}

@PropertyValidator(value=BookTitleValidator.class, message="{rpg_book_not_allowed}")
private String title;

public class BookTitleValidator implements IPropertyValidator, IWithMessage {
 
    private String message;
 
    public void setMessage(String message) throws Exception {
        this.message = message; // This message is from @PropertyValidator
    }
 
    public void validate(Messages errors, Object value, String propertyName, String modelName) {
       if (((String)value).contains("RPG")) {
           errors.add(message); // You can add it directly
       }
    }
 
}

Default validator (new in v2.0.3)

<validators>
 <default-validator>
 <validator-class
 class="org.openxava.test.validators.PersonNameValidator"/>
 <for-stereotype stereotype="PERSON_NAME"/>
 </default-validator>
</validators>

@Required @Stereotype("PERSON_NAME")
private String name;

Calculation (new in v5.7)

@Calculation("((hours * worker.hourPrice) + tripCost - discount) * vatPercentage / 100")
private BigDecimal total;

References

Customer customer = ...
customer.getSeller().getName();

@Required // 1
@Id // 2
@SearchKey // 3 New in v3.0.2
@DefaultValueCalculator // 4
@ManyToOne( // 5
 optional=false // 1
)
private type referenceName; // 5
public type getReferenceName() { ... } // 5
public void setReferenceName(type newValue) { ... } // 5

1. @ManyToOne(optional=false) (JPA), @Required (OX) (optional, the JPA is the preferred one): Indicates if the reference is required. When saving OpenXava verifies if the required references are present, if not the saving is aborted and a list of validation errors is returned.
2. @Id (JPA, optional): Indicates if the reference is part of the key. The combination of key properties and reference properties should map to a group of database columns with unique values, typically the primary key.
3. @SearchKey (OX, optional): (New in v3.0.2) The search key references are used by the user as key for searching objects. They are editable in user interface of references allowing to the user to type its value for searching. OpenXava uses the @Id members for searching by default, and if the id members are hidden then it uses the first property in the view. With @SearchKey you can choose explicitly references for searching.
4. @DefaultValueCalculator (OX, one, optional): Implements the logic for calculating the initial value of the reference. This calculator must return the key value, that can be a simple value (only if the key of referenced object is simple) or key object (a special object that wraps the key).
5. Reference declaration: A regular Java reference declaration with its getters and setters. The reference is marked with @ManyToOne (JPA) and the type must be another entity.

@ManyToOne
private Seller seller; // 1
public Seller getSeller() {
 return seller;
}
public void setSeller(Seller seller) {
 this.seller = seller;
}
 
@ManyToOne(fetch=FetchType.LAZY)
private Seller alternateSeller; // 2
public Seller getAlternateSeller() {
 return alternateSeller;
}
public void setAlternateSeller(Seller alternateSeller) {
 this.alternateSeller = alternateSeller;
}
 
 

1. A reference called seller to the entity of Seller entity.
2. A reference called alternateSeller to the entity Seller. In this case we use fetch=FetchType.LAZY, in this way the data is read from database on demand. This is the most efficient approach, but it's not the JPA default, therefore it's advisable to use always fetch=FetchType.LAZY when declaring the references.

Customer customer = ...
Seller seller = customer.getSeller();
Seller alternateSeller = customer.getAlternateSeller();
 

Default value calculator in references

@ManyToOne(optional=false, fetch=FetchType.LAZY) @JoinColumn(name="FAMILY")
@DefaultValueCalculator(value=IntegerCalculator.class, properties=
 @PropertyValue(name="value", value="2")
)
private Family family;
 

public Object calculate() throws Exception {
 return new Integer(value);
}
 

@ManyToOne(fetch=FetchType.LAZY)
@JoinColumns({
 @JoinColumn(name="ZONE", referencedColumnName="ZONE"),
 @JoinColumn(name="WAREHOUSE", referencedColumnName="NUMBER")
})
@DefaultValueCalculator(DefaultWarehouseCalculator.class)
private Warehouse warehouse;
 

package org.openxava.test.calculators;
 
import org.openxava.calculators.*;
 
/**
 * @author Javier Paniza
 */
public class DefaultWarehouseCalculator implements ICalculator {
 
  public Object calculate() throws Exception {
    Warehouse key = new Warehouse();
    key.setNumber(4);
    key.setZoneNumber(4);
    return key;
  }
 
}
 

Using references as key

@Entity
@IdClass(AdditionalDetailKey.class)
public class AdditionalDetail {
 
 // JoinColumn is also specified in AditionalDetailKey because
 // a bug in Hibernate, see http://opensource.atlassian.com/projects/hibernate/browse/ANN-361
 @Id @ManyToOne(fetch=FetchType.LAZY)
 @JoinColumn(name="SERVICE")
 private Service service;
 
 @Id @Hidden
 private int counter;
 
 ...
 
}

public class AdditionalDetailKey implements java.io.Serializable {
 
 @ManyToOne(fetch=FetchType.LAZY)
 @JoinColumn(name="SERVICE")
 private Service service;
 
 @Hidden
 private int counter;
 
 // equals, hashCode, toString, getters and setters
 ...
 
 }

Embedded reference

@Embedded
private Address address;
 

package org.openxava.test.model;
 
import javax.persistence.*;
import org.openxava.annotations.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Embeddable
public class Address implements IWithCity { // 1
 
 @Required @Column(length=30)
 private String street;
 
 @Required @Column(length=5)
 private int zipCode;
 
 @Required @Column(length=20)
 private String city;
 
 // ManyToOne inside an Embeddable is not supported by JPA 1.0 (see at 9.1.34),
 // but Hibernate implementation supports it.
 @ManyToOne(fetch=FetchType.LAZY, optional=false) @JoinColumn(name="STATE")
 private State state; // 2
 
 public String getCity() {
 return city;
 }
 
 public void setCity(String city) {
 this.city = city;
 }
 
 public String getStreet() {
 return street;
 }
 
 public void setStreet(String street) {
 this.street = street;
 }
 
 public int getZipCode() {
 return zipCode;
 }
 
 public void setZipCode(int zipCode) {
 this.zipCode = zipCode;
 }
 
 public State getState() {
 return state;
 }
 
 public void setState(State state) {
 this.state = state;
 }
 
}

Customer customer = ...
Address address = customer.getAddress();
address.getStreet(); // to obtain the value

// to set a new address
Address address = new Address();
address.setStreet(“My street”);
address.setZipCode(46001);
address.setCity(“Valencia”);
address.setState(state);
customer.setAddress(address);

Collections

Entity collections

@Size // 1
@Condition // 2
@OrderBy // 3
@XOrderBy // 4
@OrderColumn // 5  New in v5.3
@OneToMany/@ManyToMany // 6
private Collection<YourEntity> collectionName; // 5
public Collection<YourEntity> getCollectionName() { ... } // 5
public void setCollectionName(Collection<YourEntity> newValue) { ... } // 5
 

1. @Size (BV, HV, optional): Minimum (min) and/or maximum (max) number of expected elements. This is validated just before saving.
2. @Condition (OX, optional): Restricts the elements that appear in the collection. Doesn't work with @ManyToMany.
3. @OrderBy (JPA, optional): The elements in collections will be in the indicated order.
4. @XOrderBy (OX, optional): The @OrderBy of JPA does not allow to use qualified properties (properties of references). @XOrderBy does allow it.
5. @OrderColumn (JPA, optional): (New in v5.3) The order of the elements in the collection is persisted in database. A special column is created in the table to keep this order. The collection must be a java.util.List. The user interface allows the user to reorder the collection elements.
6. Collection declaration: A regular Java collection declaration with its getters and setters. The collection is marked with @OneToMany (JPA) or @ManyToMany (JPA) and the type must be another entity.

@OneToMany (mappedBy="invoice")
private Collection<Delivery> deliveries;
public Collection<Delivery> getDeliveries() {
 return deliveries;
}
public void setDeliveries(Collection<Delivery> deliveries) {
 this.deliveries = deliveries;
}

Invoice invoice = ...
for (Delivery delivery: invoice.getDeliveries()) {
 delivery.doSomething();
}

@OneToMany (mappedBy="invoice", cascade=CascadeType.REMOVE) // 1
@OrderBy("serviceType desc") // 2
@org.hibernate.validator.Size(min=1) // 3
private Collection<InvoiceDetail> details;

1. Using REMOVE as cascade type produces that when the user removes an invoice its details are also removed.
2. With @OrderBy you force that the details will be returned ordered by serviceType.
3. The restriction @Size(min=1) requires at least one detail for the invoice to be valid.

Collections with condition

@Condition(
 "${warehouse.zoneNumber} = ${this.warehouse.zoneNumber} AND " +
 "${warehouse.number} = ${this.warehouse.number} AND " +
 "NOT (${number} = ${this.number})"
)
public Collection<Carrier> getFellowCarriers() {
 return null;
}
 

Calculated collections

public Collection<Carrier> getFellowCarriers() {
 Query query = XPersistence.getManager().createQuery("from Carrier c where " +
 "c.warehouse.zoneNumber = :zone AND " +
 "c.warehouse.number = :warehouseNumber AND " +
 "NOT (c.number = :number) ");
 query.setParameter("zone", getWarehouse().getZoneNumber());
 query.setParameter("warehouseNumber", getWarehouse().getNumber());
 query.setParameter("number", getNumber());
 return query.getResultList();
}

Many-to-many collections

@Entity
public class Customer {
 ...
 @ManyToMany
 private Collection<State> states;
 ...
}
 

Embedded collections

@OneToMany (mappedBy="invoice", cascade=CascadeType.REMOVE)
private Collection details;
 

package org.openxava.test.model;
 
import java.math.*;
 
import javax.persistence.*;
 
import org.hibernate.annotations.Columns;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.Parameter;
import org.hibernate.annotations.GenericGenerator;
import org.openxava.annotations.*;
import org.openxava.calculators.*;
import org.openxava.test.validators.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@EntityValidator(value=InvoiceDetailValidator.class,
 properties= {
 @PropertyValue(name="invoice"),
 @PropertyValue(name="oid"),
 @PropertyValue(name="product"),
 @PropertyValue(name="unitPrice")
 }
)
public class InvoiceDetail {
 
 @ManyToOne // Lazy fetching produces a fails on removing a detail from invoice
 private Invoice invoice;
 
 @Id @GeneratedValue(generator="system-uuid") @Hidden
 @GenericGenerator(name="system-uuid", strategy = "uuid")
 private String oid;
 
 private ServiceType serviceType;
 public enum ServiceType { SPECIAL, URGENT }
 
 @Column(length=4) @Required
 private int quantity;
 
 @Stereotype("MONEY") @Required
 private BigDecimal unitPrice;
 
 @ManyToOne(fetch=FetchType.LAZY, optional=false)
 private Product product;
 
 @DefaultValueCalculator(CurrentDateCalculator.class)
 private java.util.Date deliveryDate;
 
 @ManyToOne(fetch=FetchType.LAZY)
 private Seller soldBy;
 
 @Stereotype("MEMO")
 private String remarks;
 
 @Stereotype("MONEY") @Depends("unitPrice, quantity")
 public BigDecimal getAmount() {
 return getUnitPrice().multiply(new BigDecimal(getQuantity()));
 }
 
 public boolean isFree() {
 return getAmount().compareTo(new BigDecimal("0")) <= 0;
 }
 
 @PostRemove
 private void postRemove() {
 invoice.setComment(invoice.getComment() + "DETAIL DELETED");
 }
 
 public String getOid() {
 return oid;
 }
 public void setOid(String oid) {
 this.oid = oid;
 }
 public ServiceType getServiceType() {
 return serviceType;
 }
 public void setServiceType(ServiceType serviceType) {
 this.serviceType = serviceType;
 }
 public int getQuantity() {
 return quantity;
 }
 public void setQuantity(int quantity) {
 this.quantity = quantity;
 }
 public BigDecimal getUnitPrice() {
 return unitPrice==null?BigDecimal.ZERO:unitPrice;
 }
 public void setUnitPrice(BigDecimal unitPrice) {
 this.unitPrice = unitPrice;
 }
 
 public Product getProduct() {
 return product;
 }
 
 public void setProduct(Product product) {
 this.product = product;
 }
 
 public java.util.Date getDeliveryDate() {
 return deliveryDate;
 }
 
 public void setDeliveryDate(java.util.Date deliveryDate) {
 this.deliveryDate = deliveryDate;
 }
 
 public Seller getSoldBy() {
 return soldBy;
 }
 
 public void setSoldBy(Seller soldBy) {
 this.soldBy = soldBy;
 }
 
 public String getRemarks() {
 return remarks;
 }
 
 public void setRemarks(String remarks) {
 this.remarks = remarks;
 }
 
 public Invoice getInvoice() {
 return invoice;
 }
 
 public void setInvoice(Invoice invoice) {
 this.invoice = invoice;
 }
 
}

Element collections (new in v5.0)

@Size // 1
@OrderBy // 2
@OrderColumn // 3  New in v5.3
@ElementCollection // 4
private Collection<YourEmbeddableClass> collectionName; // 3
public Collection<YourEmbeddableClass> getCollectionName() { ... } // 3
public void setCollectionName(Collection<YourEmbeddableClass> newValue) { ... } // 3
 

1. @Size (BV, HV, optional): Minimum (min) and/or maximum (max) number of expected elements. This is validated just before saving.
2. @OrderBy (JPA, optional): The elements in collections will be in the indicated order.
3. @OrderColumn (JPA, optional): (New in v5.3) The order of the elements in the collection is persisted in database. A special column is created in the table to keep this order. The collection must be a java.util.List. The user interface allows the user to reorder the collection elements.
4. Collection declaration: A regular Java collection declaration with its getters and setters. The collection is marked with @ElementCollection (JPA). The elements must be embeddable classes.

@Entity
public class Quote extends Identifiable {
    ...
    @ElementCollection
    private Collection<QuoteDetail> details;
 
    public Collection<QuoteDetail> getDetails() {
        return details;
    }
    public void setDetails(Collection<QuoteDetail> details) {
        this.details = details;
    }
    ...
}

@Embeddable
public class QuoteDetail {
 
    @ManyToOne(fetch=FetchType.LAZY, optional=false) // 1
    private Product product;
 
    @Required // 2
    private BigDecimal unitPrice;
 
    @Required
    private int quantity;
 
    private Date availabilityDate;
 
    @Column(length=30)
    private String remarks;
 
    @Column(precision=10, scale=2)
    @Depends("unitPrice, quantity")
    public BigDecimal getAmount() { // 3
        return getUnitPrice().multiply(new BigDecimal(getQuantity()));
    }
    ...
}

Lists with @OrderColumn (new in v5.3)

@OneToMany(mappedBy="project", cascade=CascadeType.ALL)
@OrderColumn
private List<ProjectTask> tasks;

ALTER TABLE PROJECTTASK
ADD TASKS_ORDER INTEGER

Methods

public void increasePrice() {
 setUnitPrice(getUnitPrice().multiply(new BigDecimal("1.02")).setScale(2));
}

Finders

public static Customer findByNumber(int number) throws NoResultException {
 Query query = XPersistence.getManager().createQuery(
 "from Customer as o where o.number = :number");
 query.setParameter("number", number);
 return (Customer) query.getSingleResult();
}
 
public static Collection findAll() {
 Query query = XPersistence.getManager().createQuery("from Customer as o");
 return query.getResultList();
}
 
public static Collection findByNameLike(String name) {
 Query query = XPersistence.getManager().createQuery(
 "from Customer as o where o.name like :name order by o.name desc");
 query.setParameter("name", name);
 return query.getResultList();
}

Customer customer = Customer.findByNumber(8);
Collection javieres = Customer.findByNameLike(“%JAVI%”);

Entity validator

@EntityValidator(
 value=class, // 1
 onlyOnCreate=(true|false), // 2
 properties={ @PropertyValue ... } // 3
)
 

1. value (required): Class that implements the validation logic. It has to be of type IValidator.
2. onlyOnCreate (optional): If true the validator is executed only when creating a new object, not when an existing object is modified. The default value is false.
3. properties (several @PropertyValue, optional): To set a value of the validator properties before executing it.

@EntityValidator(value=org.openxava.test.validators.CheapProductValidator.class, properties= {
 @PropertyValue(name="limit", value="100"),
 @PropertyValue(name="description"),
 @PropertyValue(name="unitPrice")
})
public class Product {

package org.openxava.test.validators;
 
import java.math.*;
 
/**
 * @author Javier Paniza
 */
 
public class CheapProductValidator implements IValidator { // 1
 
 private int limit;
 private BigDecimal unitPrice;
 private String description;
 
 public void validate(Messages errors) { // 2
 if (getDescription().indexOf("CHEAP") >= 0 ||
 getDescription().indexOf("BARATO") >= 0 ||
 getDescription().indexOf("BARATA") >= 0) {
 if (getLimiteBd().compareTo(getUnitPrice()) < 0) {
 errors.add("cheap_product", getLimitBd()); // 3
 }
 }
 }
 
 public BigDecimal getUnitPrice() {
 return unitPrice;
 }
 
 public void setUnitPrice(BigDecimal decimal) {
 unitPrice = decimal;
 }
 
 public String getDescription() {
 return description==null?"":description;
 }
 
 public void setDescription(String string) {
 description = string;
 }
 
 public int getLimit() {
 return limit;
 }
 
 public void setLimit(int i) {
 limit = i;
 }
 
 private BigDecimal getLimitBd() {
 return new BigDecimal(Integer.toString(limit));
 }
 
}
 

@EntityValidators({ // Only needed until v6.0.2
    @EntityValidator(value=org.openxava.test.validators.CheapProductValidator.class, properties= {
        @PropertyValue(name="limit", value="100"),
        @PropertyValue(name="description"),
        @PropertyValue(name="unitPrice")
    }),
    @EntityValidator(value=org.openxava.test.validators.ExpensiveProductValidator.class, properties= {
        @PropertyValue(name="limit", value="1000"),
        @PropertyValue(name="description"),
        @PropertyValue(name="unitPrice")
    }),
    @EntityValidator(value=org.openxava.test.validators.ForbiddenPriceValidator.class,
        properties= {
            @PropertyValue(name="forbiddenPrice", value="555"),
            @PropertyValue(name="unitPrice")
        },
        onlyOnCreate=true
    )
})
public class Product {

Remove validator

@RemoveValidator(
 value=class, // 1
 properties={ @PropertyValue ... } // 2
)
 

1. class (required): Class that implements the validation logic. Must implement IRemoveValidator.
2. properties (several @PropertyValue, optional): To set the value of the validator properties before executing it.

@RemoveValidator(value=DeliveryTypeRemoveValidator.class,
 properties=@PropertyValue(name="number")
)
public class DeliveryType {
 

package org.openxava.test.validators;
 
import org.openxava.test.model.*;
import org.openxava.util.*;
import org.openxava.validators.*;
 
/**
 * @author Javier Paniza
 */
public class DeliveryTypeRemoveValidator implements IRemoveValidator { // 1
 
 private DeliveryType deliveryType;
 private int number; // We use this (instead of obtaining it from deliveryType)
 // for testing @PropertyValue for simple properties
 
 public void setEntity(Object entity) throws Exception { // 2
 this.deliveryType = (DeliveryType) entity;
 }
 
 public void validate(Messages errors) throws Exception {
 if (!deliveryType.getDeliveries().isEmpty()) {
 errors.add("not_remove_delivery_type_if_in_deliveries", new Integer(getNumber())); // 3
 }
 }
 
 public int getNumber() {
 return number;
 }
 
 public void setNumber(int number) {
 this.number = number;
 }
 
}
 

JPA callback methods

@PrePersist
private void prePersist() {
 setDescription(getDescription() + " CREATED");
}

@PreUpdate
private void preUpdate() {
 setDescription(getDescription() + " MODIFIED");
}

OX callback methods (new in V4.0.1)

@PreCreate
public void onPreCreate() {
 // Automatically create a new customer
 if (getCustomer() == null) {
 Customer cust = new Customer();
 cust.setName(getName());
 cust.setAddress(getAddress());
 cust = XPersistence.getManager().merge(cust);
 setCustomer(cust);
 }
}

Inheritance

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.hibernate.annotations.*;
import org.openxava.annotations.*;
 
/**
 * Base class for defining entities with a UUID oid. <p>
 *
 * @author Javier Paniza
 */
 
@MappedSuperclass
public class Identifiable {
 
 @Id @GeneratedValue(generator="system-uuid") @Hidden
 @GenericGenerator(name="system-uuid", strategy = "uuid")
 private String oid;
 
 public String getOid() {
 return oid;
 }
 
 public void setOid(String oid) {
 this.oid = oid;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
 
/**
 * Base class for entities with a 'name' property. <p>
 *
 * @author Javier Paniza
 */
@MappedSuperclass
public class Nameable extends Identifiable {
 
 @Column(length=50) @Required
 private String name;
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@DiscriminatorColumn(name="TYPE")
@DiscriminatorValue("HUM")
@Table(name="PERSON")
@AttributeOverrides(
 @AttributeOverride(name="name", column=@Column(name="PNAME"))
)
public class Human extends Nameable {
 
 @Enumerated(EnumType.STRING)
 private Sex sex;
 public enum Sex { MALE, FEMALE };
 
 public Sex getSex() {
 return sex;
 }
 public void setSex(Sex sex) {
 this.sex = sex;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@DiscriminatorValue("PRO")
public class Programmer extends Human {
 
 @Column(length=20)
 private String mainLanguage;
 
 public String getMainLanguage() {
 return mainLanguage;
 }
 
 public void setMainLanguage(String mainLanguage) {
 this.mainLanguage = mainLanguage;
 }
 
}
 

Composite key

Id class

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
import org.openxava.jpa.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@IdClass(WarehouseKey.class)
public class Warehouse {
 
 @Id
 // Column is also specified in WarehouseKey because a bug in Hibernate, see
 // http://opensource.atlassian.com/projects/hibernate/browse/ANN-361
 @Column(length=3, name="ZONE")
 private int zoneNumber;
 
 @Id @Column(length=3)
 private int number;
 
 @Column(length=40) @Required
 private String name;
 
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
 public int getNumber() {
 return number;
 }
 
 public void setNumber(int number) {
 this.number = number;
 }
 
 public int getZoneNumber() {
 return zoneNumber;
 }
 
 public void setZoneNumber(int zoneNumber) {
 this.zoneNumber = zoneNumber;
 }
 
}
 
 

package org.openxava.test.model;
 
import java.io.*;
 
import javax.persistence.*;
 
 
/**
 *
 * @author Javier Paniza
 */
 
public class WarehouseKey implements Serializable {
 
 @Column(name="ZONE")
 private int zoneNumber;
 private int number;
 
 @Override
 public boolean equals(Object obj) {
 if (obj == null) return false;
 return obj.toString().equals(this.toString());
 }
 
 @Override
 public int hashCode() {
 return toString().hashCode();
 }
 
 @Override
 public String toString() {
 return "WarehouseKey::" + zoneNumber+ ":" + number;
 }
 
 public int getNumber() {
 return number;
 }
 
 public void setNumber(int number) {
 this.number = number;
 }
 
 public int getZoneNumber() {
 return zoneNumber;
 }
 
 public void setZoneNumber(int zoneNumber) {
 this.zoneNumber = zoneNumber;
 }
 
}

Embedded id

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
public class Warehouse {
 
 @EmbeddedId
 private WarehouseKey key;
 
 @Column(length=40) @Required
 private String name;
 
 public WarehouseKey getKey() {
 return key;
 }
 
 public void setKey(WarehouseKey key) {
 this.key = key;
 }
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Embeddable
public class WarehouseKey implements java.io.Serializable {
 
 
 @Column(length=3, name="ZONE")
 private int zoneNumber;
 
 @Column(length=3)
 private int number;
 
 public int getNumber() {
 return number;
 }
 
 public void setNumber(int number) {
 this.number = number;
 }
 
 public int getZoneNumber() {
 return zoneNumber;
 }
 
 public void setZoneNumber(int zoneNumber) {
 this.zoneNumber = zoneNumber;
 }
 
}

Bean Validation

@AssertTrue

import javax.persistence.*;
import org.openxava.annotations.*;
import org.openxava.model.*
import javax.validation.constraints.*;
 
@Entity
public class Driver extends Identifiable{
 
 @Required
 @Column(length=40)
 private String name;
 
 @AssertTrue(message="{disapproved_driving_test}")
 private boolean approvedDrivingTest;
 
 @OneToMany(mappedBy="driver")
 private Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
 
 //getters and setters...
}

disapproved_driving_test=Driver {name} can not be registered: must approve the driving test

import javax.persistence.*;
import org.openxava.annotations.*;
import org.openxava.model.*;
import javax.validation.constraints.*;
 
@Entity
public class Vehicle extends Identifiable{
 
 @Required
 @Column(length=15)
 private String type;
 
 @Required
 @Column(length=7)
 private String licensePlate;
 
 private boolean roadworthy;
 
 @ManyToOne
 private Driver driver;
 
 @AssertTrue(message="{not_roadworthy}")
 private boolean isRoadworthyToAssignTheDriver(){
     return driver == null || roadworthy;
 }
 
 //getters and setters...
}

not_roadworthy={type} plate {licensePlate} is not roadworthy. It can not be assigned to the driver {driver.name}

Hibernate Validator (new in v3.0.1)