This demo application is based on the Chinook music store sample database.
Demonstrated functionality
-
Database functions
-
Custom table cell renderer
-
See TrackTablePanel and AlbumTablePanel
-
-
Custom table cell editor
-
See TrackCellEditorFactory in TrackTablePanel
-
-
Custom input fields
-
-
Used in AlbumEditPanel
-
-
-
Used in TrackEditPanel and TrackTablePanel
-
-
Custom condition panel
-
Custom condition model operators
-
See TrackConditionModelFactory in TrackTableModel
-
-
Custom detail panel layout
-
See InvoicePanel and PlaylistPanel
-
-
Edit panel in dialog
-
See PlaylistPanel and PlaylistTrackTablePanel
-
-
Language selection
-
See ChinookAppPanel
-
-
Custom shortcut key
-
See ChinookAppPanel
-
-
Overridden resources
-
Search field selector
-
Persistance layer used in a web service
This tutorial assumes you have at least skimmed the Domain model part of the Codion manual.
Domain model
API
public interface Chinook {
DomainType DOMAIN = domainType("ChinookImpl");The domain API sections below continue the Chinook class.
Implementation
public final class ChinookImpl extends DomainModel {
public ChinookImpl() {
super(DOMAIN);
add(artist(), album(), employee(), customer(), genre(), mediaType(),
track(), invoice(), invoiceLine(), playlist(), playlistTrack());
add(Customer.REPORT, classPathReport(ChinookImpl.class, "customer_report.jasper"));
add(Track.RAISE_PRICE, new RaisePriceFunction());
add(Invoice.UPDATE_TOTALS, new UpdateTotalsFunction());
add(Playlist.RANDOM_PLAYLIST, new CreateRandomPlaylistFunction(entities()));
}The domain implementation sections below continue the ChinookImpl class.
Customers
Customer
SQL
CREATE TABLE CHINOOK.CUSTOMER
(
CUSTOMERID LONG GENERATED BY DEFAULT AS IDENTITY,
FIRSTNAME VARCHAR(40) NOT NULL,
LASTNAME VARCHAR(20) NOT NULL,
COMPANY VARCHAR(80),
ADDRESS VARCHAR(70),
CITY VARCHAR(40),
STATE VARCHAR(40),
COUNTRY VARCHAR(40),
POSTALCODE VARCHAR(10),
PHONE VARCHAR(24),
FAX VARCHAR(24),
EMAIL VARCHAR(60) NOT NULL,
SUPPORTREPID INTEGER,
CONSTRAINT PK_CUSTOMER PRIMARY KEY (CUSTOMERID),
CONSTRAINT FK_EMPLOYEE_CUSTOMER FOREIGN KEY (SUPPORTREPID) REFERENCES CHINOOK.EMPLOYEE(EMPLOYEEID)
);Domain
API
interface Customer {
EntityType TYPE = DOMAIN.entityType("customer@chinook", Customer.class.getName());
Column<Long> ID = TYPE.longColumn("customerid");
Column<String> FIRSTNAME = TYPE.stringColumn("firstname");
Column<String> LASTNAME = TYPE.stringColumn("lastname");
Column<String> COMPANY = TYPE.stringColumn("company");
Column<String> ADDRESS = TYPE.stringColumn("address");
Column<String> CITY = TYPE.stringColumn("city");
Column<String> STATE = TYPE.stringColumn("state");
Column<String> COUNTRY = TYPE.stringColumn("country");
Column<String> POSTALCODE = TYPE.stringColumn("postalcode");
Column<String> PHONE = TYPE.stringColumn("phone");
Column<String> FAX = TYPE.stringColumn("fax");
Column<String> EMAIL = TYPE.stringColumn("email");
Column<Long> SUPPORTREP_ID = TYPE.longColumn("supportrepid");
ForeignKey SUPPORTREP_FK = TYPE.foreignKey("supportrep_fk", SUPPORTREP_ID, Employee.ID);
JRReportType REPORT = JasperReports.reportType("customer_report");
} final class CustomerStringFactory
implements Function<Entity, String>, Serializable {
@Serial
private static final long serialVersionUID = 1;
@Override
public String apply(Entity customer) {
return new StringBuilder()
.append(customer.get(Customer.LASTNAME))
.append(", ")
.append(customer.get(Customer.FIRSTNAME))
.append(customer.optional(Customer.EMAIL)
.map(email -> " <" + email + ">")
.orElse(""))
.toString();
}
}Implementation
EntityDefinition customer() {
return Customer.TYPE.define(
Customer.ID.define()
.primaryKey(),
Customer.LASTNAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(20),
Customer.FIRSTNAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(40),
Customer.COMPANY.define()
.column()
.maximumLength(80),
Customer.ADDRESS.define()
.column()
.maximumLength(70),
Customer.CITY.define()
.column()
.maximumLength(40),
Customer.STATE.define()
.column()
.maximumLength(40),
Customer.COUNTRY.define()
.column()
.maximumLength(40),
Customer.POSTALCODE.define()
.column()
.maximumLength(10),
Customer.PHONE.define()
.column()
.maximumLength(24),
Customer.FAX.define()
.column()
.maximumLength(24),
Customer.EMAIL.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(60),
Customer.SUPPORTREP_ID.define()
.column(),
Customer.SUPPORTREP_FK.define()
.foreignKey()
.attributes(Employee.FIRSTNAME, Employee.LASTNAME))
.tableName("chinook.customer")
.keyGenerator(identity())
.validator(new EmailValidator(Customer.EMAIL))
.orderBy(ascending(Customer.LASTNAME, Customer.FIRSTNAME))
.stringFactory(new CustomerStringFactory())
.build();
}UI
CustomerPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;
public final class CustomerPanel extends EntityPanel {
public CustomerPanel(SwingEntityModel customerModel) {
super(customerModel, new CustomerEditPanel(customerModel.editModel()),
new CustomerTablePanel(customerModel.tableModel()));
SwingEntityModel invoiceModel = customerModel.detailModel(Invoice.TYPE);
SwingEntityModel invoiceLineModel = invoiceModel.detailModel(InvoiceLine.TYPE);
InvoiceLineTablePanel invoiceLineTablePanel = new InvoiceLineTablePanel(invoiceLineModel.tableModel());
InvoiceLineEditPanel invoiceLineEditPanel = new InvoiceLineEditPanel(invoiceLineModel.editModel(),
invoiceLineTablePanel.table().searchField());
EntityPanel invoiceLinePanel = new EntityPanel(invoiceLineModel, invoiceLineEditPanel,
invoiceLineTablePanel, config -> config.includeControls(false));
addDetailPanel(new InvoicePanel(invoiceModel, invoiceLinePanel));
}
}CustomerEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.db.exception.DatabaseException;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.JPanel;
import java.util.Collection;
import java.util.function.Supplier;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.flexibleGridLayout;
public final class CustomerEditPanel extends EntityEditPanel {
public CustomerEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Customer.FIRSTNAME);
createTextField(Customer.FIRSTNAME)
.columns(6);
createTextField(Customer.LASTNAME)
.columns(6);
createTextField(Customer.EMAIL)
.columns(12);
createTextField(Customer.COMPANY)
.columns(12);
createTextField(Customer.ADDRESS)
.columns(12);
createTextField(Customer.CITY)
.columns(8);
createTextField(Customer.POSTALCODE)
.columns(4);
createTextField(Customer.STATE)
.columns(4)
.upperCase(true)
.selector(Dialogs.singleSelector(new StatesSupplier()));
createTextField(Customer.COUNTRY)
.columns(8);
createTextField(Customer.PHONE)
.columns(12);
createTextField(Customer.FAX)
.columns(12);
createForeignKeyComboBox(Customer.SUPPORTREP_FK)
.preferredWidth(120);
JPanel firstLastNamePanel = gridLayoutPanel(1, 2)
.add(createInputPanel(Customer.FIRSTNAME))
.add(createInputPanel(Customer.LASTNAME))
.build();
JPanel cityPostalCodePanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Customer.CITY))
.add(createInputPanel(Customer.POSTALCODE))
.build();
JPanel stateCountryPanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Customer.STATE))
.add(createInputPanel(Customer.COUNTRY))
.build();
setLayout(flexibleGridLayout(4, 3));
add(firstLastNamePanel);
addInputPanel(Customer.EMAIL);
addInputPanel(Customer.COMPANY);
addInputPanel(Customer.ADDRESS);
add(cityPostalCodePanel);
add(stateCountryPanel);
addInputPanel(Customer.PHONE);
addInputPanel(Customer.FAX);
addInputPanel(Customer.SUPPORTREP_FK);
}
private class StatesSupplier implements Supplier<Collection<String>> {
@Override
public Collection<String> get() {
try {
return editModel().connection().select(Customer.STATE);
}
catch (DatabaseException e) {
throw new RuntimeException(e);
}
}
}
}CustomerTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.db.report.ReportException;
import is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.icon.FrameworkIcons;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.swing.JRViewer;
import java.awt.Dimension;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;
import static is.codion.swing.framework.ui.EntityTablePanel.ControlKeys.PRINT;
import static java.util.ResourceBundle.getBundle;
public final class CustomerTablePanel extends EntityTablePanel {
private static final ResourceBundle BUNDLE = getBundle(CustomerTablePanel.class.getName());
public CustomerTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, config -> config
.refreshButtonVisible(RefreshButtonVisible.ALWAYS));
}
@Override
protected void setupControls() {
control(PRINT).set(Control.builder()
.command(this::viewCustomerReport)
.name(BUNDLE.getString("customer_report"))
.smallIcon(FrameworkIcons.instance().print())
.enabled(tableModel().selection().empty().not())
.build());
}
private void viewCustomerReport() {
Dialogs.progressWorkerDialog(this::fillCustomerReport)
.owner(this)
.title(BUNDLE.getString("customer_report"))
.onResult(this::viewReport)
.execute();
}
private JasperPrint fillCustomerReport() throws DatabaseException, ReportException {
Collection<Long> customerIDs = Entity.values(Customer.ID,
tableModel().selection().items().get());
Map<String, Object> reportParameters = new HashMap<>();
reportParameters.put("CUSTOMER_IDS", customerIDs);
return tableModel().connection()
.report(Customer.REPORT, reportParameters);
}
private void viewReport(JasperPrint customerReport) {
Dialogs.componentDialog(new JRViewer(customerReport))
.owner(this)
.modal(false)
.title(BUNDLE.getString("customer_report"))
.size(new Dimension(800, 600))
.show();
}
}Invoice
SQL
CREATE TABLE CHINOOK.INVOICE
(
INVOICEID LONG GENERATED BY DEFAULT AS IDENTITY,
CUSTOMERID INTEGER NOT NULL,
INVOICEDATE DATE NOT NULL,
BILLINGADDRESS VARCHAR(70),
BILLINGCITY VARCHAR(40),
BILLINGSTATE VARCHAR(40),
BILLINGCOUNTRY VARCHAR(40),
BILLINGPOSTALCODE VARCHAR(10),
TOTAL DECIMAL(10, 2),
CONSTRAINT PK_INVOICE PRIMARY KEY (INVOICEID),
CONSTRAINT FK_CUSTOMER_INVOICE FOREIGN KEY (CUSTOMERID) REFERENCES CHINOOK.CUSTOMER(CUSTOMERID)
);Domain
API
interface Invoice {
EntityType TYPE = DOMAIN.entityType("invoice@chinook", Invoice.class.getName());
Column<Long> ID = TYPE.longColumn("invoiceid");
Column<Long> CUSTOMER_ID = TYPE.longColumn("customerid");
Column<LocalDate> DATE = TYPE.localDateColumn("invoicedate");
Column<String> BILLINGADDRESS = TYPE.stringColumn("billingaddress");
Column<String> BILLINGCITY = TYPE.stringColumn("billingcity");
Column<String> BILLINGSTATE = TYPE.stringColumn("billingstate");
Column<String> BILLINGCOUNTRY = TYPE.stringColumn("billingcountry");
Column<String> BILLINGPOSTALCODE = TYPE.stringColumn("billingpostalcode");
Column<BigDecimal> TOTAL = TYPE.bigDecimalColumn("total");
Column<BigDecimal> CALCULATED_TOTAL = TYPE.bigDecimalColumn("calculated_total");
ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk", CUSTOMER_ID, Customer.ID);
FunctionType<EntityConnection, Collection<Long>, Collection<Entity>> UPDATE_TOTALS = functionType("chinook.update_totals");
ValueSupplier<LocalDate> DATE_DEFAULT_VALUE = LocalDate::now;
}Implementation
EntityDefinition invoice() {
return Invoice.TYPE.define(
Invoice.ID.define()
.primaryKey(),
Invoice.CUSTOMER_ID.define()
.column()
.nullable(false),
Invoice.CUSTOMER_FK.define()
.foreignKey()
.attributes(Customer.FIRSTNAME, Customer.LASTNAME, Customer.EMAIL),
Invoice.DATE.define()
.column()
.nullable(false)
.defaultValue(Invoice.DATE_DEFAULT_VALUE)
.localeDateTimePattern(LocaleDateTimePattern.builder()
.delimiterDot()
.yearFourDigits()
.build()),
Invoice.BILLINGADDRESS.define()
.column()
.maximumLength(70),
Invoice.BILLINGCITY.define()
.column()
.maximumLength(40),
Invoice.BILLINGSTATE.define()
.column()
.maximumLength(40),
Invoice.BILLINGCOUNTRY.define()
.column()
.maximumLength(40),
Invoice.BILLINGPOSTALCODE.define()
.column()
.maximumLength(10),
Invoice.TOTAL.define()
.column()
.maximumFractionDigits(2),
Invoice.CALCULATED_TOTAL.define()
.subquery("""
SELECT SUM(unitprice * quantity)
FROM chinook.invoiceline
WHERE invoiceid = invoice.invoiceid""")
.maximumFractionDigits(2))
.tableName("chinook.invoice")
.keyGenerator(identity())
.orderBy(OrderBy.builder()
.ascending(Invoice.CUSTOMER_ID)
.descending(Invoice.DATE)
.build())
.stringFactory(Invoice.ID)
.build();
}UpdateTotalsFunction
private static final class UpdateTotalsFunction implements DatabaseFunction<EntityConnection, Collection<Long>, Collection<Entity>> {
@Override
public Collection<Entity> execute(EntityConnection connection,
Collection<Long> invoiceIds) throws DatabaseException {
Collection<Entity> invoices =
connection.select(where(Invoice.ID.in(invoiceIds))
.forUpdate()
.build());
return connection.updateSelect(invoices.stream()
.peek(UpdateTotalsFunction::updateTotal)
.filter(Entity::modified)
.collect(toList()));
}
private static void updateTotal(Entity invoice) {
invoice.put(Invoice.TOTAL, invoice.optional(Invoice.CALCULATED_TOTAL).orElse(BigDecimal.ZERO));
}
}Model
InvoiceModel
package is.codion.framework.demos.chinook.model;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.model.ForeignKeyDetailModelLink;
import is.codion.swing.framework.model.SwingEntityModel;
import javax.swing.SwingUtilities;
public final class InvoiceModel extends SwingEntityModel {
public InvoiceModel(EntityConnectionProvider connectionProvider) {
super(new InvoiceEditModel(connectionProvider));
InvoiceLineEditModel invoiceLineEditModel = new InvoiceLineEditModel(connectionProvider);
SwingEntityModel invoiceLineModel = new SwingEntityModel(invoiceLineEditModel);
ForeignKeyDetailModelLink<?, ?, ?> detailModelLink = addDetailModel(invoiceLineModel);
detailModelLink.clearForeignKeyValueOnEmptySelection().set(true);
detailModelLink.active().set(true);
invoiceLineEditModel.addTotalsUpdatedConsumer(updatedInvoices ->
SwingUtilities.invokeLater(() -> tableModel().replace(updatedInvoices)));
}
}InvoiceEditModel
package is.codion.framework.demos.chinook.model;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityEditModel;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
public final class InvoiceEditModel extends SwingEntityEditModel {
public InvoiceEditModel(EntityConnectionProvider connectionProvider) {
super(Invoice.TYPE, connectionProvider);
value(Invoice.CUSTOMER_FK).persist().set(false);
value(Invoice.CUSTOMER_FK).edited().addConsumer(this::setAddress);
}
private void setAddress(Entity customer) {
if (entity().exists().not().get()) {
if (customer == null) {
value(Invoice.BILLINGADDRESS).clear();
value(Invoice.BILLINGCITY).clear();
value(Invoice.BILLINGPOSTALCODE).clear();
value(Invoice.BILLINGSTATE).clear();
value(Invoice.BILLINGCOUNTRY).clear();
}
else {
value(Invoice.BILLINGADDRESS).set(customer.get(Customer.ADDRESS));
value(Invoice.BILLINGCITY).set(customer.get(Customer.CITY));
value(Invoice.BILLINGPOSTALCODE).set(customer.get(Customer.POSTALCODE));
value(Invoice.BILLINGSTATE).set(customer.get(Customer.STATE));
value(Invoice.BILLINGCOUNTRY).set(customer.get(Customer.COUNTRY));
}
}
}
}UI
InvoicePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;
public final class InvoicePanel extends EntityPanel {
public InvoicePanel(SwingEntityModel invoiceModel, EntityPanel invoiceLinePanel) {
super(invoiceModel, new InvoiceEditPanel(invoiceModel.editModel(), invoiceLinePanel),
new InvoiceTablePanel(invoiceModel.tableModel()),
config -> config.detailLayout(DetailLayout.NONE));
addDetailPanel(invoiceLinePanel);
}
}InvoiceEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.framework.model.EntitySearchModel;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import is.codion.swing.framework.ui.EntityPanel;
import is.codion.swing.framework.ui.component.EntitySearchField;
import is.codion.swing.framework.ui.component.EntitySearchField.Selector;
import is.codion.swing.framework.ui.component.EntitySearchField.TableSelector;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.util.function.Function;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static javax.swing.BorderFactory.createTitledBorder;
import static javax.swing.SortOrder.ASCENDING;
public final class InvoiceEditPanel extends EntityEditPanel {
private final EntityPanel invoiceLinePanel;
public InvoiceEditPanel(SwingEntityEditModel editModel, EntityPanel invoiceLinePanel) {
super(editModel, config -> config.clearAfterInsert(false));
this.invoiceLinePanel = invoiceLinePanel;
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Invoice.CUSTOMER_FK);
createForeignKeySearchField(Invoice.CUSTOMER_FK)
.columns(14)
.selectorFactory(new CustomerSelectorFactory());
createTemporalFieldPanel(Invoice.DATE)
.columns(6);
createTextField(Invoice.BILLINGADDRESS)
.columns(12)
.selectAllOnFocusGained(true);
createTextField(Invoice.BILLINGCITY)
.columns(8)
.selectAllOnFocusGained(true);
createTextField(Invoice.BILLINGPOSTALCODE)
.columns(4)
.selectAllOnFocusGained(true);
createTextField(Invoice.BILLINGSTATE)
.columns(4)
.selectAllOnFocusGained(true);
createTextField(Invoice.BILLINGCOUNTRY)
.columns(8)
.selectAllOnFocusGained(true);
JPanel customerDatePanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Invoice.CUSTOMER_FK))
.add(createInputPanel(Invoice.DATE))
.build();
JPanel cityPostalCodePanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Invoice.BILLINGCITY))
.add(createInputPanel(Invoice.BILLINGPOSTALCODE))
.build();
JPanel stateCountryPanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Invoice.BILLINGSTATE))
.add(createInputPanel(Invoice.BILLINGCOUNTRY))
.build();
JPanel cityPostalCodeStateCountryPanel = gridLayoutPanel(1, 2)
.add(cityPostalCodePanel)
.add(stateCountryPanel)
.build();
JPanel centerPanel = gridLayoutPanel(4, 1)
.add(customerDatePanel)
.add(createInputPanel(Invoice.BILLINGADDRESS))
.add(cityPostalCodeStateCountryPanel)
.build();
invoiceLinePanel.setBorder(createTitledBorder(editModel().entities().definition(InvoiceLine.TYPE).caption()));
invoiceLinePanel.initialize();
setLayout(borderLayout());
add(centerPanel, BorderLayout.CENTER);
add(invoiceLinePanel, BorderLayout.EAST);
}
private static final class CustomerSelectorFactory implements Function<EntitySearchModel, Selector> {
@Override
public Selector apply(EntitySearchModel searchModel) {
TableSelector selector = EntitySearchField.tableSelector(searchModel);
selector.table().columnModel().visible().set(Customer.LASTNAME, Customer.FIRSTNAME, Customer.EMAIL);
selector.table().model().sorter().setSortOrder(Customer.LASTNAME, ASCENDING);
selector.table().model().sorter().addSortOrder(Customer.FIRSTNAME, ASCENDING);
selector.preferredSize(new Dimension(500, 300));
return selector;
}
}
}InvoiceTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.model.condition.TableConditionModel;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.swing.common.ui.component.table.ConditionPanel;
import is.codion.swing.common.ui.component.table.FilterTableColumnModel;
import is.codion.swing.common.ui.component.table.TableConditionPanel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;
import java.util.Map;
import java.util.function.Consumer;
import static is.codion.swing.common.ui.component.table.ConditionPanel.ConditionView.SIMPLE;
public final class InvoiceTablePanel extends EntityTablePanel {
public InvoiceTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, config -> config
.editable(attributes -> attributes.remove(Invoice.TOTAL))
.conditionPanelFactory(new InvoiceConditionPanelFactory(tableModel))
.conditionView(SIMPLE));
}
private static final class InvoiceConditionPanelFactory implements TableConditionPanel.Factory<Attribute<?>> {
private final SwingEntityTableModel tableModel;
private InvoiceConditionPanelFactory(SwingEntityTableModel tableModel) {
this.tableModel = tableModel;
}
@Override
public TableConditionPanel<Attribute<?>> create(TableConditionModel<Attribute<?>> tableConditionModel,
Map<Attribute<?>, ConditionPanel<?>> conditionPanels,
FilterTableColumnModel<Attribute<?>> columnModel,
Consumer<TableConditionPanel<Attribute<?>>> onPanelInitialized) {
return new InvoiceConditionPanel(tableModel, conditionPanels, columnModel, onPanelInitialized);
}
}
}InvoiceConditionPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.Operator;
import is.codion.common.item.Item;
import is.codion.common.model.condition.ConditionModel;
import is.codion.common.model.condition.TableConditionModel;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.EntityDefinition;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.framework.model.ForeignKeyConditionModel;
import is.codion.swing.common.ui.component.Components;
import is.codion.swing.common.ui.component.table.ConditionPanel;
import is.codion.swing.common.ui.component.table.ConditionPanel.ConditionView;
import is.codion.swing.common.ui.component.table.FilterTableColumnModel;
import is.codion.swing.common.ui.component.table.FilterTableConditionPanel;
import is.codion.swing.common.ui.component.table.TableConditionPanel;
import is.codion.swing.common.ui.component.text.NumberField;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.key.KeyEvents;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.component.EntitySearchField;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.SpinnerListModel;
import javax.swing.SwingConstants;
import java.awt.BorderLayout;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.time.LocalDate;
import java.time.Month;
import java.time.YearMonth;
import java.time.format.TextStyle;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.function.Consumer;
import java.util.stream.Stream;
import static is.codion.swing.common.ui.component.Components.borderLayoutPanel;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.component.table.ConditionPanel.ConditionView.ADVANCED;
import static is.codion.swing.common.ui.component.table.FilterTableConditionPanel.filterTableConditionPanel;
import static is.codion.swing.common.ui.control.Control.command;
import static java.time.Month.DECEMBER;
import static java.time.Month.JANUARY;
import static java.util.Arrays.asList;
import static java.util.Objects.requireNonNull;
import static java.util.ResourceBundle.getBundle;
import static javax.swing.BorderFactory.createEmptyBorder;
import static javax.swing.BorderFactory.createTitledBorder;
import static javax.swing.border.TitledBorder.CENTER;
import static javax.swing.border.TitledBorder.DEFAULT_POSITION;
final class InvoiceConditionPanel extends TableConditionPanel<Attribute<?>> {
private static final ResourceBundle BUNDLE = getBundle(InvoiceConditionPanel.class.getName());
private final FilterTableConditionPanel<Attribute<?>> advancedConditionPanel;
private final SimpleConditionPanel simpleConditionPanel;
InvoiceConditionPanel(SwingEntityTableModel tableModel,
Map<Attribute<?>, ConditionPanel<?>> conditionPanels,
FilterTableColumnModel<Attribute<?>> columnModel,
Consumer<TableConditionPanel<Attribute<?>>> onPanelInitialized) {
super(tableModel.queryModel().conditions(), attribute -> columnModel.column(attribute).getHeaderValue().toString());
setLayout(new BorderLayout());
this.simpleConditionPanel = new SimpleConditionPanel(tableModel.queryModel().conditions(), tableModel);
this.advancedConditionPanel = filterTableConditionPanel(tableModel.queryModel().conditions(),
conditionPanels, columnModel, onPanelInitialized);
view().link(advancedConditionPanel.view());
}
@Override
public Map<Attribute<?>, ConditionPanel<?>> get() {
Map<Attribute<?>, ConditionPanel<?>> conditionPanels =
new HashMap<>(advancedConditionPanel.get());
conditionPanels.putAll(simpleConditionPanel.panels());
return conditionPanels;
}
@Override
public Map<Attribute<?>, ConditionPanel<?>> selectable() {
return view().isEqualTo(ADVANCED) ? advancedConditionPanel.selectable() : simpleConditionPanel.panels();
}
@Override
public <T extends ConditionPanel<?>> T get(Attribute<?> attribute) {
if (view().isNotEqualTo(ADVANCED)) {
return (T) simpleConditionPanel.panel(attribute);
}
return advancedConditionPanel.get(attribute);
}
@Override
public Controls controls() {
return advancedConditionPanel.controls();
}
@Override
protected void onViewChanged(ConditionView conditionView) {
removeAll();
switch (conditionView) {
case SIMPLE:
add(simpleConditionPanel, BorderLayout.CENTER);
simpleConditionPanel.activate();
break;
case ADVANCED:
add(advancedConditionPanel, BorderLayout.CENTER);
if (simpleConditionPanel.customerConditionPanel.isFocused()) {
advancedConditionPanel.get(Invoice.CUSTOMER_FK).requestInputFocus();
}
else if (simpleConditionPanel.dateConditionPanel.isFocused()) {
advancedConditionPanel.get(Invoice.DATE).requestInputFocus();
}
break;
default:
break;
}
revalidate();
}
private static final class SimpleConditionPanel extends JPanel {
private final Map<Attribute<?>, ConditionPanel<?>> conditionPanels = new HashMap<>();
private final CustomerConditionPanel customerConditionPanel;
private final DateConditionPanel dateConditionPanel;
private SimpleConditionPanel(TableConditionModel<Attribute<?>> tableConditionModel,
SwingEntityTableModel tableModel) {
super(new BorderLayout());
setBorder(createEmptyBorder(5, 5, 5, 5));
customerConditionPanel = new CustomerConditionPanel(tableConditionModel.get(Invoice.CUSTOMER_FK), tableModel.entityDefinition());
dateConditionPanel = new DateConditionPanel(tableConditionModel.get(Invoice.DATE));
dateConditionPanel.yearValue.addListener(tableModel::refresh);
dateConditionPanel.monthValue.addListener(tableModel::refresh);
conditionPanels.put(Invoice.CUSTOMER_FK, customerConditionPanel);
conditionPanels.put(Invoice.DATE, dateConditionPanel);
initializeUI();
}
private void initializeUI() {
add(borderLayoutPanel()
.westComponent(borderLayoutPanel()
.westComponent(customerConditionPanel)
.centerComponent(dateConditionPanel)
.build())
.build(), BorderLayout.CENTER);
}
private Map<Attribute<?>, ConditionPanel<?>> panels() {
return conditionPanels;
}
private ConditionPanel<?> panel(Attribute<?> attribute) {
requireNonNull(attribute);
ConditionPanel<?> conditionPanel = panels().get(attribute);
if (conditionPanel == null) {
throw new IllegalStateException("No condition panel available for " + attribute);
}
return conditionPanel;
}
private void activate() {
customerConditionPanel.condition().operator().set(Operator.IN);
dateConditionPanel.condition().operator().set(Operator.BETWEEN);
customerConditionPanel.requestInputFocus();
}
private static final class CustomerConditionPanel extends ConditionPanel<Entity> {
private final EntitySearchField searchField;
private CustomerConditionPanel(ConditionModel<Entity> condition, EntityDefinition definition) {
super(condition);
setLayout(new BorderLayout());
setBorder(createTitledBorder(createEmptyBorder(), definition.attributes().definition(Invoice.CUSTOMER_FK).caption()));
ForeignKeyConditionModel foreignKeyCondition = (ForeignKeyConditionModel) condition;
foreignKeyCondition.operands().in().value().link(foreignKeyCondition.operands().equal());
searchField = EntitySearchField.builder(foreignKeyCondition.inSearchModel())
.columns(25)
.build();
add(searchField, BorderLayout.CENTER);
}
@Override
public Collection<JComponent> components() {
return List.of(searchField);
}
@Override
public void requestInputFocus() {
searchField.requestFocusInWindow();
}
@Override
protected void onViewChanged(ConditionView conditionView) {}
private boolean isFocused() {
return searchField.hasFocus();
}
}
private static final class DateConditionPanel extends ConditionPanel<LocalDate> {
private final ComponentValue<Integer, NumberField<Integer>> yearValue = Components.integerField()
.value(LocalDate.now().getYear())
.listener(this::updateCondition)
.focusable(false)
.columns(4)
.horizontalAlignment(SwingConstants.CENTER)
.buildValue();
private final ComponentValue<Month, JSpinner> monthValue = Components.<Month>itemSpinner(new MonthSpinnerModel())
.listener(this::updateCondition)
.editable(false)
.columns(3)
.horizontalAlignment(SwingConstants.LEFT)
.keyEvent(KeyEvents.builder(KeyEvent.VK_UP)
.modifiers(InputEvent.CTRL_DOWN_MASK)
.action(command(this::incrementYear)))
.keyEvent(KeyEvents.builder(KeyEvent.VK_DOWN)
.modifiers(InputEvent.CTRL_DOWN_MASK)
.action(command(this::decrementYear)))
.buildValue();
private DateConditionPanel(ConditionModel<LocalDate> conditionModel) {
super(conditionModel);
condition().operator().set(Operator.BETWEEN);
updateCondition();
initializeUI();
}
@Override
protected void onViewChanged(ConditionView conditionView) {}
private void initializeUI() {
setLayout(new BorderLayout());
add(flexibleGridLayoutPanel(1, 2)
.add(borderLayoutPanel()
.centerComponent(yearValue.component())
.border(createTitledBorder(createEmptyBorder(),
BUNDLE.getString("year"), CENTER, DEFAULT_POSITION))
.build())
.add(borderLayoutPanel()
.centerComponent(monthValue.component())
.border(createTitledBorder(createEmptyBorder(),
BUNDLE.getString("month")))
.build())
.build(), BorderLayout.CENTER);
}
private void incrementYear() {
yearValue.map(year -> year + 1);
}
private void decrementYear() {
yearValue.map(year -> year - 1);
}
@Override
public Collection<JComponent> components() {
return asList(yearValue.component(), monthValue.component());
}
@Override
public void requestInputFocus() {
monthValue.component().requestFocusInWindow();
}
private void updateCondition() {
condition().operands().lowerBound().set(lowerBound());
condition().operands().upperBound().set(upperBound());
}
private LocalDate lowerBound() {
int year = yearValue.optional().orElse(LocalDate.now().getYear());
Month month = monthValue.optional().orElse(JANUARY);
return LocalDate.of(year, month, 1);
}
private LocalDate upperBound() {
int year = yearValue.optional().orElse(LocalDate.now().getYear());
Month month = monthValue.optional().orElse(DECEMBER);
YearMonth yearMonth = YearMonth.of(year, month);
return LocalDate.of(year, month, yearMonth.lengthOfMonth());
}
private boolean isFocused() {
return yearValue.component().hasFocus() || monthValue.component().hasFocus();
}
private static final class MonthSpinnerModel extends SpinnerListModel {
private MonthSpinnerModel() {
super(createMonthsList());
}
private static List<Item<Month>> createMonthsList() {
return Stream.concat(Stream.of(Item.<Month>item(null, "")), Arrays.stream(Month.values())
.map(month -> Item.item(month, month.getDisplayName(TextStyle.SHORT, Locale.getDefault()))))
.toList();
}
}
}
}
}Invoice Line
SQL
CREATE TABLE CHINOOK.INVOICELINE
(
INVOICELINEID LONG GENERATED BY DEFAULT AS IDENTITY,
INVOICEID INTEGER NOT NULL,
TRACKID INTEGER NOT NULL,
UNITPRICE DOUBLE NOT NULL,
QUANTITY INTEGER NOT NULL,
CONSTRAINT PK_INVOICELINE PRIMARY KEY (INVOICELINEID),
CONSTRAINT FK_TRACK_INVOICELINE FOREIGN KEY (TRACKID) REFERENCES CHINOOK.TRACK(TRACKID),
CONSTRAINT FK_INVOICE_INVOICELINE FOREIGN KEY (INVOICEID) REFERENCES CHINOOK.INVOICE(INVOICEID),
CONSTRAINT UK_INVOICELINE_INVOICE_TRACK UNIQUE (INVOICEID, TRACKID)
);Domain
API
interface InvoiceLine {
EntityType TYPE = DOMAIN.entityType("invoiceline@chinook", InvoiceLine.class.getName());
Column<Long> ID = TYPE.longColumn("invoicelineid");
Column<Long> INVOICE_ID = TYPE.longColumn("invoiceid");
Column<Long> TRACK_ID = TYPE.longColumn("trackid");
Column<BigDecimal> UNITPRICE = TYPE.bigDecimalColumn("unitprice");
Column<Integer> QUANTITY = TYPE.integerColumn("quantity");
Column<BigDecimal> TOTAL = TYPE.bigDecimalColumn("total");
ForeignKey INVOICE_FK = TYPE.foreignKey("invoice_fk", INVOICE_ID, Invoice.ID);
ForeignKey TRACK_FK = TYPE.foreignKey("track_fk", TRACK_ID, Track.ID);
} final class InvoiceLineTotalProvider
implements DerivedAttribute.Provider<BigDecimal> {
@Serial
private static final long serialVersionUID = 1;
@Override
public BigDecimal get(SourceValues values) {
Integer quantity = values.get(InvoiceLine.QUANTITY);
BigDecimal unitPrice = values.get(InvoiceLine.UNITPRICE);
if (unitPrice == null || quantity == null) {
return null;
}
return unitPrice.multiply(BigDecimal.valueOf(quantity));
}
}Implementation
EntityDefinition invoiceLine() {
return InvoiceLine.TYPE.define(
InvoiceLine.ID.define()
.primaryKey(),
InvoiceLine.INVOICE_ID.define()
.column()
.nullable(false),
InvoiceLine.INVOICE_FK.define()
.foreignKey(0)
.hidden(true),
InvoiceLine.TRACK_ID.define()
.column()
.nullable(false),
InvoiceLine.TRACK_FK.define()
.foreignKey()
.attributes(Track.NAME, Track.UNITPRICE),
InvoiceLine.UNITPRICE.define()
.column()
.nullable(false),
InvoiceLine.QUANTITY.define()
.column()
.nullable(false)
.defaultValue(1),
InvoiceLine.TOTAL.define()
.derived(new InvoiceLineTotalProvider(),
InvoiceLine.QUANTITY, InvoiceLine.UNITPRICE))
.tableName("chinook.invoiceline")
.keyGenerator(identity())
.build();
}Model
InvoiceLineEditModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.event.Event;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityEditModel;
import java.util.Collection;
import java.util.function.Consumer;
import static is.codion.framework.db.EntityConnection.transaction;
import static is.codion.framework.domain.entity.Entity.distinct;
import static is.codion.framework.domain.entity.Entity.primaryKeys;
public final class InvoiceLineEditModel extends SwingEntityEditModel {
private final Event<Collection<Entity>> totalsUpdatedEvent = Event.event();
public InvoiceLineEditModel(EntityConnectionProvider connectionProvider) {
super(InvoiceLine.TYPE, connectionProvider);
value(InvoiceLine.TRACK_FK).edited().addConsumer(this::setUnitPrice);
}
void addTotalsUpdatedConsumer(Consumer<Collection<Entity>> consumer) {
totalsUpdatedEvent.addConsumer(consumer);
}
@Override
protected Collection<Entity> insert(Collection<Entity> invoiceLines, EntityConnection connection) throws DatabaseException {
return transaction(connection, () -> updateTotals(connection.insertSelect(invoiceLines), connection));
}
@Override
protected Collection<Entity> update(Collection<Entity> invoiceLines, EntityConnection connection) throws DatabaseException {
return transaction(connection, () -> updateTotals(connection.updateSelect(invoiceLines), connection));
}
@Override
protected void delete(Collection<Entity> invoiceLines, EntityConnection connection) throws DatabaseException {
transaction(connection, () -> {
connection.delete(primaryKeys(invoiceLines));
updateTotals(invoiceLines, connection);
});
}
private void setUnitPrice(Entity track) {
value(InvoiceLine.UNITPRICE).set(track == null ? null : track.get(Track.UNITPRICE));
}
private Collection<Entity> updateTotals(Collection<Entity> invoiceLines, EntityConnection connection) throws DatabaseException {
totalsUpdatedEvent.accept(connection.execute(Invoice.UPDATE_TOTALS, distinct(InvoiceLine.INVOICE_ID, invoiceLines)));
return invoiceLines;
}
}InvoiceLineEditModelTest
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.ChinookImpl;
import is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entities;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.exception.ValidationException;
import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import java.time.LocalDate;
import static is.codion.framework.domain.entity.condition.Condition.key;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
public final class InvoiceLineEditModelTest {
@Test
void updateTotals() throws DatabaseException, ValidationException {
try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
EntityConnection connection = connectionProvider.connection();
Entity invoice = createInvoice(connection);
assertNull(invoice.get(Invoice.TOTAL));
Entity battery = connection.selectSingle(Track.NAME.equalToIgnoreCase("battery"));
InvoiceLineEditModel editModel = new InvoiceLineEditModel(connectionProvider);
editModel.value(InvoiceLine.INVOICE_FK).set(invoice);
editModel.value(InvoiceLine.TRACK_FK).set(battery);
Entity invoiceLineBattery = editModel.insert();
invoice = connection.selectSingle(key(invoice.primaryKey()));
assertEquals(battery.get(Track.UNITPRICE), invoice.get(Invoice.TOTAL));
Entity orion = connection.selectSingle(Track.NAME.equalToIgnoreCase("orion"));
editModel.entity().defaults();
editModel.value(InvoiceLine.INVOICE_FK).set(invoice);
editModel.value(InvoiceLine.TRACK_FK).set(orion);
editModel.insert();
invoice = connection.selectSingle(key(invoice.primaryKey()));
assertEquals(battery.get(Track.UNITPRICE).add(orion.get(Track.UNITPRICE)), invoice.get(Invoice.TOTAL));
Entity theCallOfKtulu = connection.selectSingle(Track.NAME.equalToIgnoreCase("the call of ktulu"));
theCallOfKtulu.put(Track.UNITPRICE, BigDecimal.valueOf(2));
theCallOfKtulu = connection.updateSelect(theCallOfKtulu);
editModel.entity().set(invoiceLineBattery);
editModel.value(InvoiceLine.TRACK_FK).set(theCallOfKtulu);
editModel.update();
invoice = connection.selectSingle(key(invoice.primaryKey()));
assertEquals(orion.get(Track.UNITPRICE).add(theCallOfKtulu.get(Track.UNITPRICE)), invoice.get(Invoice.TOTAL));
editModel.delete();
invoice = connection.selectSingle(key(invoice.primaryKey()));
assertEquals(orion.get(Track.UNITPRICE), invoice.get(Invoice.TOTAL));
}
}
private static Entity createInvoice(EntityConnection connection) throws DatabaseException {
Entities entities = connection.entities();
return connection.insertSelect(entities.builder(Invoice.TYPE)
.with(Invoice.CUSTOMER_FK, connection.insertSelect(entities.builder(Customer.TYPE)
.with(Customer.FIRSTNAME, "Björn")
.with(Customer.LASTNAME, "Sigurðsson")
.with(Customer.EMAIL, "email@email.com")
.build()))
.with(Invoice.DATE, LocalDate.now())
.build());
}
private static EntityConnectionProvider createConnectionProvider() {
return LocalEntityConnectionProvider.builder()
.domain(new ChinookImpl())
.user(User.parse("scott:tiger"))
.build();
}
}UI
InvoiceLineEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToolBar;
import java.awt.BorderLayout;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.component.Components.toolBar;
import static is.codion.swing.common.ui.component.text.TextComponents.preferredTextFieldHeight;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static is.codion.swing.framework.ui.EntityEditPanel.ControlKeys.INSERT;
import static is.codion.swing.framework.ui.EntityEditPanel.ControlKeys.UPDATE;
public final class InvoiceLineEditPanel extends EntityEditPanel {
private final JTextField tableSearchField;
public InvoiceLineEditPanel(SwingEntityEditModel editModel, JTextField tableSearchField) {
super(editModel);
this.tableSearchField = tableSearchField;
editModel.value(InvoiceLine.TRACK_FK).persist().set(false);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(InvoiceLine.TRACK_FK);
createForeignKeySearchField(InvoiceLine.TRACK_FK)
.selectorFactory(new TrackSelectorFactory())
.columns(15);
createTextField(InvoiceLine.QUANTITY)
.selectAllOnFocusGained(true)
.columns(2)
.action(control(INSERT).get());
JToolBar updateToolBar = toolBar()
.floatable(false)
.action(control(UPDATE).get())
.preferredHeight(preferredTextFieldHeight())
.build();
JPanel centerPanel = flexibleGridLayoutPanel(1, 0)
.add(createInputPanel(InvoiceLine.TRACK_FK))
.add(createInputPanel(InvoiceLine.QUANTITY))
.add(createInputPanel(new JLabel(" "), updateToolBar))
.add(createInputPanel(new JLabel(" "), tableSearchField))
.build();
setLayout(borderLayout());
add(centerPanel, BorderLayout.CENTER);
}
}InvoiceLineTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;
import javax.swing.JTable;
import java.awt.Dimension;
public final class InvoiceLineTablePanel extends EntityTablePanel {
public InvoiceLineTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, config -> config
.includeSouthPanel(false)
.includeConditions(false)
.includeFilters(false)
.editable(attributes -> attributes.remove(InvoiceLine.INVOICE_FK))
.editComponentFactory(InvoiceLine.TRACK_FK, new TrackComponentFactory(InvoiceLine.TRACK_FK)));
table().setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
setPreferredSize(new Dimension(360, 40));
}
}Employees
Employee
SQL
CREATE TABLE CHINOOK.EMPLOYEE
(
EMPLOYEEID LONG GENERATED BY DEFAULT AS IDENTITY,
LASTNAME VARCHAR(20) NOT NULL,
FIRSTNAME VARCHAR(20) NOT NULL,
TITLE VARCHAR(30),
REPORTSTO INTEGER,
BIRTHDATE DATE,
HIREDATE DATE,
ADDRESS VARCHAR(70),
CITY VARCHAR(40),
STATE VARCHAR(40),
COUNTRY VARCHAR(40),
POSTALCODE VARCHAR(10),
PHONE VARCHAR(24),
FAX VARCHAR(24),
EMAIL VARCHAR(60) NOT NULL,
CONSTRAINT PK_EMPLOYEE PRIMARY KEY (EMPLOYEEID),
CONSTRAINT FK_EMPLOYEE_REPORTSTO FOREIGN KEY (REPORTSTO) REFERENCES CHINOOK.EMPLOYEE(EMPLOYEEID)
);Domain
API
interface Employee {
EntityType TYPE = DOMAIN.entityType("employee@chinook", Employee.class.getName());
Column<Long> ID = TYPE.longColumn("employeeid");
Column<String> LASTNAME = TYPE.stringColumn("lastname");
Column<String> FIRSTNAME = TYPE.stringColumn("firstname");
Column<String> TITLE = TYPE.stringColumn("title");
Column<Long> REPORTSTO = TYPE.longColumn("reportsto");
Column<LocalDate> BIRTHDATE = TYPE.localDateColumn("birthdate");
Column<LocalDate> HIREDATE = TYPE.localDateColumn("hiredate");
Column<String> ADDRESS = TYPE.stringColumn("address");
Column<String> CITY = TYPE.stringColumn("city");
Column<String> STATE = TYPE.stringColumn("state");
Column<String> COUNTRY = TYPE.stringColumn("country");
Column<String> POSTALCODE = TYPE.stringColumn("postalcode");
Column<String> PHONE = TYPE.stringColumn("phone");
Column<String> FAX = TYPE.stringColumn("fax");
Column<String> EMAIL = TYPE.stringColumn("email");
ForeignKey REPORTSTO_FK = TYPE.foreignKey("reportsto_fk", REPORTSTO, Employee.ID);
} final class EmailValidator extends DefaultEntityValidator {
private static final Pattern EMAIL_PATTERN = Pattern.compile("^(.+)@(.+)$");
private static final ResourceBundle BUNDLE = getBundle(Chinook.class.getName());
private final Column<String> emailColumn;
public EmailValidator(Column<String> emailColumn) {
this.emailColumn = emailColumn;
}
@Override
public <T> void validate(Entity entity, Attribute<T> attribute) throws ValidationException {
super.validate(entity, attribute);
if (attribute.equals(emailColumn)) {
validateEmail(entity.get(emailColumn));
}
}
private void validateEmail(String email) throws ValidationException {
if (!EMAIL_PATTERN.matcher(email).matches()) {
throw new ValidationException(emailColumn, email, BUNDLE.getString("invalid_email"));
}
}
}Implementation
EntityDefinition employee() {
return Employee.TYPE.define(
Employee.ID.define()
.primaryKey(),
Employee.LASTNAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(20),
Employee.FIRSTNAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(20),
Employee.TITLE.define()
.column()
.maximumLength(30),
Employee.REPORTSTO.define()
.column(),
Employee.REPORTSTO_FK.define()
.foreignKey()
.attributes(Employee.FIRSTNAME, Employee.LASTNAME),
Employee.BIRTHDATE.define()
.column(),
Employee.HIREDATE.define()
.column()
.localeDateTimePattern(LocaleDateTimePattern.builder()
.delimiterDot()
.yearFourDigits()
.build()),
Employee.ADDRESS.define()
.column()
.maximumLength(70),
Employee.CITY.define()
.column()
.maximumLength(40),
Employee.STATE.define()
.column()
.maximumLength(40),
Employee.COUNTRY.define()
.column()
.maximumLength(40),
Employee.POSTALCODE.define()
.column()
.maximumLength(10),
Employee.PHONE.define()
.column()
.maximumLength(24),
Employee.FAX.define()
.column()
.maximumLength(24),
Employee.EMAIL.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(60))
.tableName("chinook.employee")
.keyGenerator(identity())
.validator(new EmailValidator(Employee.EMAIL))
.orderBy(ascending(Employee.LASTNAME, Employee.FIRSTNAME))
.stringFactory(StringFactory.builder()
.value(Employee.LASTNAME)
.text(", ")
.value(Employee.FIRSTNAME)
.build())
.build();
}UI
EmployeeEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.JPanel;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Employee;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.flexibleGridLayout;
final class EmployeeEditPanel extends EntityEditPanel {
EmployeeEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Employee.FIRSTNAME);
createTextField(Employee.FIRSTNAME)
.columns(6);
createTextField(Employee.LASTNAME)
.columns(6);
createTemporalFieldPanel(Employee.BIRTHDATE)
.columns(6);
createTemporalFieldPanel(Employee.HIREDATE)
.columns(6);
createTextField(Employee.TITLE)
.columns(8);
createTextField(Employee.ADDRESS);
createTextField(Employee.CITY)
.columns(8);
createTextField(Employee.POSTALCODE)
.columns(4);
createTextField(Employee.STATE)
.columns(4)
.upperCase(true);
createTextField(Employee.COUNTRY)
.columns(8);
createTextField(Employee.PHONE)
.columns(12);
createTextField(Employee.FAX)
.columns(12);
createTextField(Employee.EMAIL)
.columns(12);
createForeignKeyComboBox(Employee.REPORTSTO_FK)
.preferredWidth(120)
.transferFocusOnEnter(false);
JPanel firstLastNamePanel = gridLayoutPanel(1, 2)
.add(createInputPanel(Employee.FIRSTNAME))
.add(createInputPanel(Employee.LASTNAME))
.build();
JPanel birthHireDatePanel = gridLayoutPanel(1, 2)
.add(createInputPanel(Employee.BIRTHDATE))
.add(createInputPanel(Employee.HIREDATE))
.build();
JPanel cityPostalCodePanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Employee.CITY))
.add(createInputPanel(Employee.POSTALCODE))
.build();
JPanel stateCountryPanel = flexibleGridLayoutPanel(1, 2)
.add(createInputPanel(Employee.STATE))
.add(createInputPanel(Employee.COUNTRY))
.build();
setLayout(flexibleGridLayout(4, 3));
add(firstLastNamePanel);
add(birthHireDatePanel);
addInputPanel(Employee.TITLE);
addInputPanel(Employee.ADDRESS);
add(cityPostalCodePanel);
add(stateCountryPanel);
addInputPanel(Employee.PHONE);
addInputPanel(Employee.FAX);
addInputPanel(Employee.EMAIL);
addInputPanel(Employee.REPORTSTO_FK);
}
}EmployeeTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;
public final class EmployeeTablePanel extends EntityTablePanel {
public EmployeeTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, new EmployeeEditPanel(tableModel.editModel()));
}
}Albums
We start with a few support tables, artist, genre and media type.
Artist
SQL
CREATE TABLE CHINOOK.ARTIST
(
ARTISTID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(120) NOT NULL,
CONSTRAINT PK_ARTIST PRIMARY KEY (ARTISTID),
CONSTRAINT UK_ARTIST UNIQUE (NAME)
);Domain
API
interface Artist {
EntityType TYPE = DOMAIN.entityType("artist@chinook", Artist.class.getName());
Column<Long> ID = TYPE.longColumn("artistid");
Column<String> NAME = TYPE.stringColumn("name");
Column<Integer> NUMBER_OF_ALBUMS = TYPE.integerColumn("number_of_albums");
Column<Integer> NUMBER_OF_TRACKS = TYPE.integerColumn("number_of_tracks");
static Dto dto(Entity artist) {
return artist == null ? null :
new Dto(artist.get(ID), artist.get(NAME));
}
record Dto(Long id, String name) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(NAME, name)
.build();
}
}
}Implementation
EntityDefinition artist() {
return Artist.TYPE.define(
Artist.ID.define()
.primaryKey(),
Artist.NAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(120),
Artist.NUMBER_OF_ALBUMS.define()
.subquery("""
SELECT COUNT(*)
FROM chinook.album
WHERE album.artistid = artist.artistid"""),
Artist.NUMBER_OF_TRACKS.define()
.subquery("""
SELECT COUNT(*)
FROM chinook.track
JOIN chinook.album ON track.albumid = album.albumid
WHERE album.artistid = artist.artistid"""))
.tableName("chinook.artist")
.keyGenerator(identity())
.orderBy(ascending(Artist.NAME))
.stringFactory(Artist.NAME)
.build();
}UI
ArtistEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import static is.codion.swing.common.ui.layout.Layouts.gridLayout;
public final class ArtistEditPanel extends EntityEditPanel {
public ArtistEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Artist.NAME);
createTextField(Artist.NAME)
.columns(18);
setLayout(gridLayout(1, 1));
addInputPanel(Artist.NAME);
}
}Genre
SQL
CREATE TABLE CHINOOK.GENRE
(
GENREID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(120) NOT NULL,
CONSTRAINT PK_GENRE PRIMARY KEY (GENREID),
CONSTRAINT UK_GENRE UNIQUE (NAME)
);Domain
API
interface Genre {
EntityType TYPE = DOMAIN.entityType("genre@chinook", Genre.class.getName());
Column<Long> ID = TYPE.longColumn("genreid");
Column<String> NAME = TYPE.stringColumn("name");
static Dto dto(Entity genre) {
return genre == null ? null :
new Dto(genre.get(ID), genre.get(NAME));
}
record Dto(Long id, String name) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(NAME, name)
.build();
}
}
}Implementation
EntityDefinition genre() {
return Genre.TYPE.define(
Genre.ID.define()
.primaryKey(),
Genre.NAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(120))
.tableName("chinook.genre")
.keyGenerator(identity())
.orderBy(ascending(Genre.NAME))
.stringFactory(Genre.NAME)
.smallDataset(true)
.build();
}UI
GenreEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import static is.codion.swing.common.ui.layout.Layouts.gridLayout;
public final class GenreEditPanel extends EntityEditPanel {
public GenreEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Genre.NAME);
createTextField(Genre.NAME);
setLayout(gridLayout(1, 1));
addInputPanel(Genre.NAME);
}
}Media Type
SQL
CREATE TABLE CHINOOK.MEDIATYPE
(
MEDIATYPEID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(120) NOT NULL,
CONSTRAINT PK_MEDIATYPE PRIMARY KEY (MEDIATYPEID),
CONSTRAINT UK_MEDIATYPE UNIQUE (NAME)
);Domain
API
interface MediaType {
EntityType TYPE = DOMAIN.entityType("mediatype@chinook", MediaType.class.getName());
Column<Long> ID = TYPE.longColumn("mediatypeid");
Column<String> NAME = TYPE.stringColumn("name");
static Dto dto(Entity mediaType) {
return mediaType == null ? null :
new Dto(mediaType.get(ID), mediaType.get(NAME));
}
record Dto(Long id, String name) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(NAME, name)
.build();
}
}
}Implementation
EntityDefinition mediaType() {
return MediaType.TYPE.define(
MediaType.ID.define()
.primaryKey(),
MediaType.NAME.define()
.column()
.nullable(false)
.maximumLength(120))
.tableName("chinook.mediatype")
.keyGenerator(identity())
.stringFactory(MediaType.NAME)
.smallDataset(true)
.build();
}UI
MediaTypeEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.MediaType;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import static is.codion.swing.common.ui.layout.Layouts.gridLayout;
public final class MediaTypeEditPanel extends EntityEditPanel {
public MediaTypeEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(MediaType.NAME);
createTextField(MediaType.NAME);
setLayout(gridLayout(1, 1));
addInputPanel(MediaType.NAME);
}
}Artist
SQL
CREATE TABLE CHINOOK.ARTIST
(
ARTISTID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(120) NOT NULL,
CONSTRAINT PK_ARTIST PRIMARY KEY (ARTISTID),
CONSTRAINT UK_ARTIST UNIQUE (NAME)
);Domain
API
interface Artist {
EntityType TYPE = DOMAIN.entityType("artist@chinook", Artist.class.getName());
Column<Long> ID = TYPE.longColumn("artistid");
Column<String> NAME = TYPE.stringColumn("name");
Column<Integer> NUMBER_OF_ALBUMS = TYPE.integerColumn("number_of_albums");
Column<Integer> NUMBER_OF_TRACKS = TYPE.integerColumn("number_of_tracks");
static Dto dto(Entity artist) {
return artist == null ? null :
new Dto(artist.get(ID), artist.get(NAME));
}
record Dto(Long id, String name) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(NAME, name)
.build();
}
}
}Implementation
EntityDefinition artist() {
return Artist.TYPE.define(
Artist.ID.define()
.primaryKey(),
Artist.NAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(120),
Artist.NUMBER_OF_ALBUMS.define()
.subquery("""
SELECT COUNT(*)
FROM chinook.album
WHERE album.artistid = artist.artistid"""),
Artist.NUMBER_OF_TRACKS.define()
.subquery("""
SELECT COUNT(*)
FROM chinook.track
JOIN chinook.album ON track.albumid = album.albumid
WHERE album.artistid = artist.artistid"""))
.tableName("chinook.artist")
.keyGenerator(identity())
.orderBy(ascending(Artist.NAME))
.stringFactory(Artist.NAME)
.build();
}UI
Album
SQL
CREATE TABLE CHINOOK.ALBUM
(
ALBUMID LONG GENERATED BY DEFAULT AS IDENTITY,
TITLE VARCHAR(160) NOT NULL,
ARTISTID INTEGER NOT NULL,
COVER BLOB,
TAGS VARCHAR ARRAY,
CONSTRAINT PK_ALBUM PRIMARY KEY (ALBUMID),
CONSTRAINT FK_ARTIST_ALBUM FOREIGN KEY (ARTISTID) REFERENCES CHINOOK.ARTIST(ARTISTID)
);Domain
API
interface Album {
EntityType TYPE = DOMAIN.entityType("album@chinook", Album.class.getName());
Column<Long> ID = TYPE.longColumn("albumid");
Column<String> TITLE = TYPE.stringColumn("title");
Column<Long> ARTIST_ID = TYPE.longColumn("artistid");
Column<byte[]> COVER = TYPE.byteArrayColumn("cover");
Column<Integer> NUMBER_OF_TRACKS = TYPE.integerColumn("number_of_tracks");
Column<List<String>> TAGS = TYPE.column("tags", new TypeReference<>() {});
Column<Integer> RATING = TYPE.integerColumn("rating");
ForeignKey ARTIST_FK = TYPE.foreignKey("artist_fk", ARTIST_ID, Artist.ID);
static Dto dto(Entity album) {
return album == null ? null :
new Dto(album.get(ID), album.get(TITLE),
Artist.dto(album.get(ARTIST_FK)));
}
record Dto(Long id, String title, Artist.Dto artist) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(TITLE, title)
.with(ARTIST_FK, artist.entity(entities))
.build();
}
}
}Implementation
EntityDefinition album() {
return Album.TYPE.define(
Album.ID.define()
.primaryKey(),
Album.ARTIST_ID.define()
.column()
.nullable(false),
Album.ARTIST_FK.define()
.foreignKey()
.attributes(Artist.NAME),
Album.TITLE.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(160),
Album.COVER.define()
.column()
.format(new CoverFormatter()),
Album.NUMBER_OF_TRACKS.define()
.subquery("""
SELECT COUNT(*)
FROM chinook.track
WHERE track.albumid = album.albumid"""),
Album.TAGS.define()
.column()
.columnClass(Array.class, new TagsConverter(), ResultSet::getArray),
Album.RATING.define()
.subquery("""
SELECT AVG(rating)
FROM chinook.track
WHERE track.albumid = album.albumid"""))
.tableName("chinook.album")
.keyGenerator(identity())
.orderBy(ascending(Album.ARTIST_ID, Album.TITLE))
.stringFactory(Album.TITLE)
.build();
} private static final class TagsConverter implements Column.Converter<List<String>, Array> {
private static final int ARRAY_VALUE_INDEX = 2;
private final ResultPacker<String> packer = resultSet -> resultSet.getString(ARRAY_VALUE_INDEX);
@Override
public Array toColumnValue(List<String> value, Statement statement) throws SQLException {
return value.isEmpty() ? null :
statement.getConnection().createArrayOf("VARCHAR", value.toArray(new Object[0]));
}
@Override
public List<String> fromColumnValue(Array columnValue) throws SQLException {
try (ResultSet resultSet = columnValue.getResultSet()) {
return packer.pack(resultSet);
}
}
}UI
AlbumModel
package is.codion.framework.demos.chinook.model;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.swing.framework.model.SwingEntityModel;
public final class AlbumModel extends SwingEntityModel {
public AlbumModel(EntityConnectionProvider connectionProvider) {
super(Album.TYPE, connectionProvider);
SwingEntityModel trackModel = new SwingEntityModel(new TrackTableModel(connectionProvider));
addDetailModel(trackModel);
TrackEditModel trackEditModel = trackModel.editModel();
trackEditModel.initializeComboBoxModels(Track.MEDIATYPE_FK, Track.GENRE_FK);
trackEditModel.ratingUpdated().addConsumer(tableModel()::refresh);
}
}package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.ChinookImpl;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.exception.ValidationException;
import is.codion.swing.framework.model.SwingEntityTableModel;
import org.junit.jupiter.api.Test;
import java.util.List;
import static is.codion.framework.db.EntityConnection.Update.where;
import static org.junit.jupiter.api.Assertions.assertEquals;
public final class AlbumModelTest {
private static final String MASTER_OF_PUPPETS = "Master Of Puppets";
@Test
void albumRefreshedWhenTrackRatingIsUpdated() throws DatabaseException, ValidationException {
try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
EntityConnection connection = connectionProvider.connection();
connection.startTransaction();
// Initialize all the tracks with an inital rating of 8
Entity masterOfPuppets = connection.selectSingle(Album.TITLE.equalTo(MASTER_OF_PUPPETS));
connection.update(where(Track.ALBUM_FK.equalTo(masterOfPuppets))
.set(Track.RATING, 8)
.build());
// Re-select the album to get the updated rating, which is the average of the track ratings
masterOfPuppets = connection.selectSingle(Album.TITLE.equalTo(MASTER_OF_PUPPETS));
assertEquals(8, masterOfPuppets.get(Album.RATING));
// Create our AlbumModel and configure the query condition
// to populate it with only Master Of Puppets
AlbumModel albumModel = new AlbumModel(connectionProvider);
SwingEntityTableModel albumTableModel = albumModel.tableModel();
albumTableModel.queryModel().conditions().setEqualOperand(Album.TITLE, MASTER_OF_PUPPETS);
albumTableModel.refresh();
assertEquals(1, albumTableModel.items().count());
List<Entity> modifiedTracks = connection.select(Track.ALBUM_FK.equalTo(masterOfPuppets)).stream()
.peek(track -> track.put(Track.RATING, 10))
.toList();
// Update the tracks using the edit model
TrackEditModel trackEditModel = albumModel.detailModel(Track.TYPE).editModel();
trackEditModel.update(modifiedTracks);
// Which should trigger the refresh of the album in the Album model
// now with the new rating as the average of the track ratings
assertEquals(10, albumTableModel.items().visible().itemAt(0).get(Album.RATING));
connection.rollbackTransaction();
}
}
private static EntityConnectionProvider createConnectionProvider() {
return LocalEntityConnectionProvider.builder()
.domain(new ChinookImpl())
.user(User.parse("scott:tiger"))
.build();
}
}UI
AlbumPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;
public final class AlbumPanel extends EntityPanel {
public AlbumPanel(SwingEntityModel albumModel) {
super(albumModel, new AlbumEditPanel(albumModel.editModel()), new AlbumTablePanel(albumModel.tableModel()));
SwingEntityModel trackModel = albumModel.detailModel(Track.TYPE);
EntityPanel trackPanel = new EntityPanel(trackModel,
new TrackEditPanel(trackModel.editModel(), trackModel.tableModel()),
new TrackTablePanel(trackModel.tableModel()));
addDetailPanel(trackPanel);
}
}AlbumEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.util.List;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import static is.codion.swing.common.ui.component.Components.flexibleGridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
public final class AlbumEditPanel extends EntityEditPanel {
public AlbumEditPanel(SwingEntityEditModel editModel) {
super(editModel);
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Album.ARTIST_FK);
createForeignKeySearchField(Album.ARTIST_FK)
.columns(15)
.editPanel(this::createArtistEditPanel);
createTextField(Album.TITLE)
.columns(15);
ComponentValue<List<String>, JList<String>> tagsValue =
createList(new DefaultListModel<String>())
.items(Album.TAGS)
.buildValue();
component(Album.COVER).set(new CoverArtPanel(editModel().value(Album.COVER)));
JPanel centerPanel = flexibleGridLayoutPanel(2, 2)
.add(createInputPanel(Album.ARTIST_FK))
.add(createInputPanel(Album.TITLE))
.add(createInputPanel(Album.TAGS, new AlbumTagPanel(tagsValue)))
.add(createInputPanel(Album.COVER))
.build();
setLayout(borderLayout());
add(centerPanel, BorderLayout.CENTER);
}
private EntityEditPanel createArtistEditPanel() {
return new ArtistEditPanel(new SwingEntityEditModel(Artist.TYPE, editModel().connectionProvider()));
}
}CoverArtPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.state.State;
import is.codion.common.value.Value;
import is.codion.plugin.imagepanel.NavigableImagePanel;
import is.codion.swing.common.ui.FileTransferHandler;
import is.codion.swing.common.ui.Utilities;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.ui.icon.FrameworkIcons;
import org.kordamp.ikonli.foundation.Foundation;
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.ResourceBundle;
import static is.codion.swing.common.ui.component.Components.borderLayoutPanel;
import static is.codion.swing.common.ui.component.Components.buttonPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.util.ResourceBundle.getBundle;
import static javax.swing.BorderFactory.createEtchedBorder;
/**
* A panel for displaying a cover image, based on a byte array.
*/
final class CoverArtPanel extends JPanel {
private static final ResourceBundle BUNDLE = getBundle(CoverArtPanel.class.getName());
private static final FrameworkIcons ICONS = FrameworkIcons.instance();
private static final Dimension EMBEDDED_SIZE = new Dimension(200, 200);
private static final Dimension DIALOG_SIZE = new Dimension(400, 400);
private static final FileNameExtensionFilter IMAGE_FILE_FILTER =
new FileNameExtensionFilter(BUNDLE.getString("images"),
new String[] {"jpg", "jpeg", "png", "bmp", "gif"});
private final JPanel centerPanel;
private final NavigableImagePanel imagePanel;
private final Value<byte[]> imageBytes;
private final State imageSelected;
private final State embedded = State.state(true);
/**
* @param imageBytes the image bytes value to base this panel on.
*/
CoverArtPanel(Value<byte[]> imageBytes) {
super(borderLayout());
this.imageBytes = imageBytes;
this.imageSelected = State.state(imageBytes.isNotNull());
this.imagePanel = createImagePanel();
this.centerPanel = createCenterPanel();
add(centerPanel, BorderLayout.CENTER);
bindEvents();
}
private JPanel createCenterPanel() {
return borderLayoutPanel()
.preferredSize(EMBEDDED_SIZE)
.centerComponent(imagePanel)
.southComponent(borderLayoutPanel()
.eastComponent(buttonPanel(Controls.builder()
.control(Control.builder()
.command(this::selectCover)
.smallIcon(ICONS.icon(Foundation.PLUS)))
.control(Control.builder()
.command(this::removeCover)
.smallIcon(ICONS.icon(Foundation.MINUS))
.enabled(imageSelected)))
.buttonBuilder(buttonBuilder -> buttonBuilder.transferFocusOnEnter(true))
.buttonGap(0)
.build())
.build())
.build();
}
private void bindEvents() {
imageBytes.addConsumer(bytes -> imagePanel.setImage(readImage(bytes)));
imageBytes.addConsumer(bytes -> imageSelected.set(bytes != null));
embedded.addConsumer(this::setEmbedded);
imagePanel.addMouseListener(new EmbeddingMouseListener());
}
private void selectCover() throws IOException {
File coverFile = Dialogs.fileSelectionDialog()
.owner(this)
.title(BUNDLE.getString("select_image"))
.fileFilter(IMAGE_FILE_FILTER)
.selectFile();
imageBytes.set(Files.readAllBytes(coverFile.toPath()));
}
private void removeCover() {
imageBytes.clear();
}
private void setEmbedded(boolean embedded) {
configureImagePanel(embedded);
if (embedded) {
embed();
}
else {
displayInDialog();
}
}
private void embed() {
Utilities.disposeParentWindow(centerPanel);
centerPanel.setSize(EMBEDDED_SIZE);
imagePanel.resetView();
add(centerPanel, BorderLayout.CENTER);
revalidate();
repaint();
}
private void displayInDialog() {
remove(centerPanel);
revalidate();
repaint();
Dialogs.componentDialog(centerPanel)
.owner(this)
.modal(false)
.title(BUNDLE.getString("cover"))
.onClosed(windowEvent -> embedded.set(true))
.onOpened(windowEvent -> imagePanel.resetView())
.size(DIALOG_SIZE)
.show();
}
private void configureImagePanel(boolean embedded) {
imagePanel.setZoomDevice(embedded ? NavigableImagePanel.ZoomDevice.NONE : NavigableImagePanel.ZoomDevice.MOUSE_WHEEL);
imagePanel.setMoveImageEnabled(!embedded);
}
private NavigableImagePanel createImagePanel() {
NavigableImagePanel panel = new NavigableImagePanel();
panel.setZoomDevice(NavigableImagePanel.ZoomDevice.NONE);
panel.setNavigationImageEnabled(false);
panel.setMoveImageEnabled(false);
panel.setTransferHandler(new CoverTransferHandler());
panel.setBorder(createEtchedBorder());
return panel;
}
private static BufferedImage readImage(byte[] bytes) {
if (bytes == null) {
return null;
}
try {
return ImageIO.read(new ByteArrayInputStream(bytes));
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
private final class EmbeddingMouseListener extends MouseAdapter {
@Override
public void mouseClicked(MouseEvent e) {
if (e.getClickCount() == 2) {
embedded.set(!embedded.get());
}
}
}
private final class CoverTransferHandler extends FileTransferHandler {
@Override
protected boolean importFiles(Component component, List<File> files) {
try {
if (singleImage(files)) {
imageBytes.set(Files.readAllBytes(files.getFirst().toPath()));
return true;
}
return false;
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
private boolean singleImage(List<File> files) {
return files.size() == 1 && IMAGE_FILE_FILTER.accept(files.getFirst());
}
}
}AlbumTagPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.state.State;
import is.codion.framework.i18n.FrameworkMessages;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.key.KeyEvents;
import is.codion.swing.framework.ui.icon.FrameworkIcons;
import org.kordamp.ikonli.foundation.Foundation;
import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import java.awt.BorderLayout;
import java.util.Arrays;
import java.util.List;
import static is.codion.swing.common.ui.component.Components.*;
import static is.codion.swing.common.ui.dialog.Dialogs.inputDialog;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.awt.event.InputEvent.CTRL_DOWN_MASK;
import static java.awt.event.KeyEvent.*;
final class AlbumTagPanel extends JPanel {
private static final FrameworkIcons ICONS = FrameworkIcons.instance();
private final ComponentValue<List<String>, JList<String>> tagsValue;
private final DefaultListModel<String> tagListModel;
private final State selectionEmpty = State.state(true);
private final State movingTags = State.state(false);
private final Control addTagControl = Control.builder()
.command(this::addTag)
.smallIcon(ICONS.icon(Foundation.PLUS))
.build();
private final Control removeTagControl = Control.builder()
.command(this::removeTag)
.smallIcon(ICONS.icon(Foundation.MINUS))
.enabled(selectionEmpty.not())
.build();
private final Control moveSelectionUpControl = Control.builder()
.command(this::moveSelectedTagsUp)
.smallIcon(ICONS.up())
.enabled(selectionEmpty.not())
.build();
private final Control moveSelectionDownControl = Control.builder()
.command(this::moveSelectedTagsDown)
.smallIcon(ICONS.down())
.enabled(selectionEmpty.not())
.build();
AlbumTagPanel(ComponentValue<List<String>, JList<String>> tagsValue) {
super(borderLayout());
this.tagsValue = tagsValue;
this.tagsValue.component().addListSelectionListener(new UpdateSelectionEmptyState());
this.tagListModel = (DefaultListModel<String>) tagsValue.component().getModel();
add(createCenterPanel(), BorderLayout.CENTER);
setupKeyEvents();
}
ComponentValue<List<String>, JList<String>> tagsValue() {
return tagsValue;
}
private JPanel createCenterPanel() {
return borderLayoutPanel()
.centerComponent(scrollPane(tagsValue.component())
.preferredWidth(120)
.build())
.southComponent(borderLayoutPanel()
.westComponent(createButtonPanel(moveSelectionDownControl, moveSelectionUpControl))
.eastComponent(createButtonPanel(addTagControl, removeTagControl))
.build())
.build();
}
private JPanel createButtonPanel(Control leftControl, Control rightControl) {
return buttonPanel(Controls.builder()
.control(leftControl)
.control(rightControl))
.buttonBuilder(buttonBuilder -> buttonBuilder.transferFocusOnEnter(true))
.buttonGap(0)
.build();
}
private void setupKeyEvents() {
KeyEvents.builder(VK_INSERT)
.action(addTagControl)
.enable(tagsValue.component());
KeyEvents.builder(VK_DELETE)
.action(removeTagControl)
.enable(tagsValue.component());
KeyEvents.builder(VK_UP)
.modifiers(CTRL_DOWN_MASK)
.action(moveSelectionUpControl)
.enable(tagsValue.component());
KeyEvents.builder(VK_DOWN)
.modifiers(CTRL_DOWN_MASK)
.action(moveSelectionDownControl)
.enable(tagsValue.component());
}
private void addTag() {
ComponentValue<String, JTextField> tagValue = stringField().buildValue();
State tagNotNull = State.state(false);
tagValue.observer().addListener(() -> tagNotNull.set(tagValue.isNotNull()));
tagListModel.addElement(inputDialog(tagValue)
.owner(this)
.title(FrameworkMessages.add())
.valid(tagNotNull)
.show());
}
private void removeTag() {
tagsValue.component().getSelectedValuesList().forEach(tagListModel::removeElement);
}
private void moveSelectedTagsUp() {
movingTags.set(true);
try {
int[] selected = tagsValue.component().getSelectedIndices();
if (selected.length > 0 && selected[0] != 0) {
moveTagsUp(selected);
moveSelectionUp(selected);
}
}
finally {
movingTags.set(false);
}
}
private void moveSelectedTagsDown() {
movingTags.set(true);
try {
int[] selected = tagsValue.component().getSelectedIndices();
if (selected.length > 0 && selected[selected.length - 1] != tagListModel.getSize() - 1) {
moveTagsDown(selected);
moveSelectionDown(selected);
}
}
finally {
movingTags.set(false);
}
}
private void moveTagsUp(int[] selected) {
for (int i = 0; i < selected.length; i++) {
tagListModel.add(selected[i] - 1, tagListModel.remove(selected[i]));
}
}
private void moveTagsDown(int[] selected) {
for (int i = selected.length - 1; i >= 0; i--) {
tagListModel.add(selected[i] + 1, tagListModel.remove(selected[i]));
}
}
private void moveSelectionUp(int[] selected) {
tagsValue.component().setSelectedIndices(Arrays.stream(selected)
.map(index -> index - 1)
.toArray());
tagsValue.component().ensureIndexIsVisible(selected[0] - 1);
}
private void moveSelectionDown(int[] selected) {
tagsValue.component().setSelectedIndices(Arrays.stream(selected)
.map(index -> index + 1)
.toArray());
tagsValue.component().ensureIndexIsVisible(selected[selected.length - 1] + 1);
}
private final class UpdateSelectionEmptyState implements ListSelectionListener {
@Override
public void valueChanged(ListSelectionEvent e) {
if (!movingTags.get()) {
selectionEmpty.set(tagsValue.component().isSelectionEmpty());
}
}
}
}AlbumTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.plugin.imagepanel.NavigableImagePanel;
import is.codion.swing.common.ui.Utilities;
import is.codion.swing.common.ui.Windows;
import is.codion.swing.common.ui.component.Components;
import is.codion.swing.common.ui.component.value.AbstractComponentValue;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTableCellRenderer;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.component.EntityComponentFactory;
import javax.imageio.ImageIO;
import javax.swing.DefaultListModel;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.List;
import static is.codion.framework.demos.chinook.ui.TrackTablePanel.RATINGS;
public final class AlbumTablePanel extends EntityTablePanel {
private final NavigableImagePanel imagePanel;
public AlbumTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, config -> config
.editComponentFactory(Album.TAGS, new TagEditComponentFactory())
.cellRenderer(Album.RATING, EntityTableCellRenderer.builder(Album.RATING, tableModel)
.string(RATINGS::get)
.toolTipData(true)
.build()));
imagePanel = new NavigableImagePanel();
imagePanel.setPreferredSize(Windows.screenSizeRatio(0.5));
table().doubleClickAction().set(viewCoverControl());
}
private Control viewCoverControl() {
return Control.builder()
.command(this::viewSelectedCover)
.enabled(tableModel().selection().single())
.build();
}
private void viewSelectedCover() {
tableModel().selection().item().optional()
.filter(album -> album.isNotNull(Album.COVER))
.ifPresent(album -> displayImage(album.get(Album.TITLE), album.get(Album.COVER)));
}
private void displayImage(String title, byte[] imageBytes) {
imagePanel.setImage(readImage(imageBytes));
if (imagePanel.isShowing()) {
Utilities.parentDialog(imagePanel).toFront();
}
else {
Dialogs.componentDialog(imagePanel)
.owner(Utilities.parentWindow(this))
.title(title)
.modal(false)
.onClosed(dialog -> imagePanel.setImage(null))
.show();
}
}
private static BufferedImage readImage(byte[] bytes) {
try {
return ImageIO.read(new ByteArrayInputStream(bytes));
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
private static final class TagEditComponentFactory
implements EntityComponentFactory<List<String>, AlbumTagPanel> {
@Override
public ComponentValue<List<String>, AlbumTagPanel> componentValue(SwingEntityEditModel editModel,
List<String> value) {
return new TagComponentValue(value);
}
}
private static final class TagComponentValue extends AbstractComponentValue<List<String>, AlbumTagPanel> {
private TagComponentValue(List<String> tags) {
super(new AlbumTagPanel(Components.list(new DefaultListModel<String>())
.items()
.value(tags)
.buildValue()));
}
@Override
protected List<String> getComponentValue() {
return component().tagsValue().get();
}
@Override
protected void setComponentValue(List<String> value) {
component().tagsValue().set(value);
}
}
}Track
SQL
CREATE TABLE CHINOOK.TRACK
(
TRACKID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(200) NOT NULL,
ALBUMID INTEGER NOT NULL,
MEDIATYPEID INTEGER NOT NULL,
GENREID INTEGER,
COMPOSER VARCHAR(220),
MILLISECONDS INTEGER NOT NULL,
BYTES DOUBLE,
RATING INTEGER NOT NULL,
UNITPRICE DOUBLE NOT NULL,
CONSTRAINT PK_TRACK PRIMARY KEY (TRACKID),
CONSTRAINT FK_ALBUM_TRACK FOREIGN KEY (ALBUMID) REFERENCES CHINOOK.ALBUM(ALBUMID),
CONSTRAINT FK_MEDIATYPE_TRACK FOREIGN KEY (MEDIATYPEID) REFERENCES CHINOOK.MEDIATYPE(MEDIATYPEID),
CONSTRAINT FK_GENRE_TRACK FOREIGN KEY (GENREID) REFERENCES CHINOOK.GENRE(GENREID),
CONSTRAINT CHK_RATING CHECK (RATING BETWEEN 1 AND 10)
);Domain
API
interface Track {
EntityType TYPE = DOMAIN.entityType("track@chinook", Track.class.getName());
Column<Long> ID = TYPE.longColumn("trackid");
Column<String> NAME = TYPE.stringColumn("name");
Attribute<Entity> ARTIST = TYPE.entityAttribute("artist");
Column<Long> ALBUM_ID = TYPE.longColumn("albumid");
Column<Long> MEDIATYPE_ID = TYPE.longColumn("mediatypeid");
Column<Long> GENRE_ID = TYPE.longColumn("genreid");
Column<String> COMPOSER = TYPE.stringColumn("composer");
Column<Integer> MILLISECONDS = TYPE.integerColumn("milliseconds");
Column<Integer> BYTES = TYPE.integerColumn("bytes");
Column<Integer> RATING = TYPE.integerColumn("rating");
Column<BigDecimal> UNITPRICE = TYPE.bigDecimalColumn("unitprice");
Column<Void> RANDOM = TYPE.column("random()", Void.class);
ForeignKey ALBUM_FK = TYPE.foreignKey("album_fk", ALBUM_ID, Album.ID);
ForeignKey MEDIATYPE_FK = TYPE.foreignKey("mediatype_fk", MEDIATYPE_ID, MediaType.ID);
ForeignKey GENRE_FK = TYPE.foreignKey("genre_fk", GENRE_ID, Genre.ID);
FunctionType<EntityConnection, RaisePriceParameters, Collection<Entity>> RAISE_PRICE = functionType("chinook.raise_price");
ConditionType NOT_IN_PLAYLIST = TYPE.conditionType("not_in_playlist");
static Dto dto(Entity track) {
return track == null ? null :
new Dto(track.get(ID), track.get(NAME),
Album.dto(track.get(ALBUM_FK)),
Genre.dto(track.get(GENRE_FK)),
MediaType.dto(track.get(MEDIATYPE_FK)),
track.get(MILLISECONDS),
track.get(RATING),
track.get(UNITPRICE));
}
record RaisePriceParameters(Collection<Long> trackIds, BigDecimal priceIncrease) implements Serializable {
public RaisePriceParameters {
requireNonNull(trackIds);
requireNonNull(priceIncrease);
}
}
record Dto(Long id, String name, Album.Dto album,
Genre.Dto genre, MediaType.Dto mediaType,
Integer milliseconds, Integer rating,
BigDecimal unitPrice) {
public Entity entity(Entities entities) {
return entities.builder(TYPE)
.with(ID, id)
.with(NAME, name)
.with(ALBUM_FK, album.entity(entities))
.with(GENRE_FK, genre.entity(entities))
.with(MEDIATYPE_FK, mediaType.entity(entities))
.with(MILLISECONDS, milliseconds)
.with(RATING, rating)
.with(UNITPRICE, unitPrice)
.build();
}
}
} final class CoverFormatter extends Format {
private final NumberFormat kbFormat = NumberFormat.getIntegerInstance();
@Override
public StringBuffer format(Object value, StringBuffer toAppendTo, FieldPosition pos) {
if (value != null) {
toAppendTo.append(kbFormat.format(((byte[]) value).length / 1024) + " Kb");
}
return toAppendTo;
}
@Override
public Object parseObject(String source, ParsePosition pos) {
throw new UnsupportedOperationException();
}
}Implementation
EntityDefinition track() {
return Track.TYPE.define(
Track.ID.define()
.primaryKey(),
Track.ALBUM_ID.define()
.column()
.nullable(false),
Track.ALBUM_FK.define()
.foreignKey(2)
.attributes(Album.ARTIST_FK, Album.TITLE),
Track.ARTIST.define()
.denormalized(Track.ALBUM_FK, Album.ARTIST_FK),
Track.NAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(200),
Track.GENRE_ID.define()
.column(),
Track.GENRE_FK.define()
.foreignKey(),
Track.COMPOSER.define()
.column()
.maximumLength(220),
Track.MEDIATYPE_ID.define()
.column()
.nullable(false),
Track.MEDIATYPE_FK.define()
.foreignKey(),
Track.MILLISECONDS.define()
.column()
.nullable(false)
.format(NumberFormat.getIntegerInstance()),
Track.BYTES.define()
.column()
.format(NumberFormat.getIntegerInstance()),
Track.RATING.define()
.column()
.nullable(false)
.defaultValue(5)
.valueRange(1, 10),
Track.UNITPRICE.define()
.column()
.nullable(false)
.minimumValue(0)
.maximumFractionDigits(2),
Track.RANDOM.define()
.column()
.readOnly(true)
.selectable(false))
.tableName("chinook.track")
.keyGenerator(identity())
.orderBy(ascending(Track.NAME))
.condition(Track.NOT_IN_PLAYLIST, new NotInPlaylistConditionProvider())
.stringFactory(Track.NAME)
.build();
} private static final class NotInPlaylistConditionProvider implements ConditionProvider {
@Override
public String toString(List<Column<?>> columns, List<?> values) {
return new StringBuilder("""
trackid NOT IN (
SELECT trackid
FROM chinook.playlisttrack
WHERE playlistid IN (""")
.append(join(", ", nCopies(values.size(), "?"))).append(")\n")
.append(")")
.toString();
}
} private static final class RaisePriceFunction implements DatabaseFunction<EntityConnection, RaisePriceParameters, Collection<Entity>> {
@Override
public Collection<Entity> execute(EntityConnection entityConnection,
RaisePriceParameters parameters) throws DatabaseException {
Select select =
where(Track.ID.in(parameters.trackIds()))
.forUpdate()
.build();
return entityConnection.updateSelect(entityConnection.select(select).stream()
.peek(track -> raisePrice(track, parameters.priceIncrease()))
.collect(toList()));
}
private static void raisePrice(Entity track, BigDecimal priceIncrease) {
track.put(Track.UNITPRICE, track.get(Track.UNITPRICE).add(priceIncrease));
}
}Model
TrackEditModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.event.Event;
import is.codion.common.observer.Observer;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityEditModel;
import java.util.Collection;
import java.util.List;
public final class TrackEditModel extends SwingEntityEditModel {
private final Event<Collection<Entity.Key>> ratingUpdated = Event.event();
public TrackEditModel(EntityConnectionProvider connectionProvider) {
super(Track.TYPE, connectionProvider);
}
Observer<Collection<Entity.Key>> ratingUpdated() {
return ratingUpdated.observer();
}
@Override
protected Collection<Entity> update(Collection<Entity> entities, EntityConnection connection) throws DatabaseException {
List<Entity.Key> albumKeys = entities.stream()
.filter(entity -> entity.entityType().equals(Track.TYPE))
.filter(track -> track.modified(Track.RATING))
.map(track -> track.key(Track.ALBUM_FK))
.toList();
Collection<Entity> updated = super.update(entities, connection);
ratingUpdated.accept(albumKeys);
return updated;
}
}TrackTableModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.model.condition.ConditionModel;
import is.codion.common.value.Value;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track.RaisePriceParameters;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.swing.framework.model.SwingAttributeConditionModelFactory;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.model.SwingForeignKeyConditionModel;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Optional;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import static is.codion.framework.model.EntityConditionModel.entityConditionModel;
import static is.codion.framework.model.EntityQueryModel.entityQueryModel;
public final class TrackTableModel extends SwingEntityTableModel {
private static final int DEFAULT_LIMIT = 1_000;
private static final int MAXIMUM_LIMIT = 10_000;
public TrackTableModel(EntityConnectionProvider connectionProvider) {
super(new TrackEditModel(connectionProvider),
entityQueryModel(entityConditionModel(Track.TYPE, connectionProvider,
new TrackColumnConditionFactory(connectionProvider))));
editable().set(true);
configureLimit();
}
public void raisePriceOfSelected(BigDecimal increase) throws DatabaseException {
if (selection().empty().not().get()) {
Collection<Long> trackIds = Entity.values(Track.ID, selection().items().get());
Collection<Entity> result = connection()
.execute(Track.RAISE_PRICE, new RaisePriceParameters(trackIds, increase));
replace(result);
}
}
private void configureLimit() {
queryModel().limit().set(DEFAULT_LIMIT);
queryModel().limit().addListener(this::refresh);
queryModel().limit().addValidator(new LimitValidator());
}
private static final class LimitValidator implements Value.Validator<Integer> {
@Override
public void validate(Integer limit) {
if (limit != null && limit > MAXIMUM_LIMIT) {
// The error message is never displayed, so not required
throw new IllegalArgumentException();
}
}
}
private static class TrackColumnConditionFactory extends SwingAttributeConditionModelFactory {
private TrackColumnConditionFactory(EntityConnectionProvider connectionProvider) {
super(connectionProvider);
}
@Override
public Optional<ConditionModel<?>> create(Attribute<?> attribute) {
if (attribute.equals(Track.MEDIATYPE_FK)) {
return Optional.of(SwingForeignKeyConditionModel.builder()
.includeEqualOperators(createEqualComboBoxModel(Track.MEDIATYPE_FK))
.build());
}
return super.create(attribute);
}
}
}package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.ChinookImpl;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import static org.junit.jupiter.api.Assertions.assertEquals;
public final class TrackTableModelTest {
@Test
public void raisePriceOfSelected() throws DatabaseException {
try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
Entity masterOfPuppets = connectionProvider.connection()
.selectSingle(Album.TITLE.equalTo("Master Of Puppets"));
TrackTableModel trackTableModel = new TrackTableModel(connectionProvider);
trackTableModel.queryModel().conditions()
.setEqualOperand(Track.ALBUM_FK, masterOfPuppets);
trackTableModel.refresh();
assertEquals(8, trackTableModel.items().visible().count());
trackTableModel.selection().selectAll();
trackTableModel.raisePriceOfSelected(BigDecimal.ONE);
trackTableModel.items().get().forEach(track ->
assertEquals(BigDecimal.valueOf(1.99), track.get(Track.UNITPRICE)));
}
}
private static EntityConnectionProvider createConnectionProvider() {
return LocalEntityConnectionProvider.builder()
.domain(new ChinookImpl())
.user(User.parse("scott:tiger"))
.build();
}
}UI
TrackEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.common.ui.key.KeyEvents;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.JPanel;
import static is.codion.framework.demos.chinook.domain.api.Chinook.*;
import static is.codion.swing.common.ui.component.Components.borderLayoutPanel;
import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.control.Control.command;
import static is.codion.swing.common.ui.layout.Layouts.flexibleGridLayout;
import static java.awt.event.InputEvent.CTRL_DOWN_MASK;
import static java.awt.event.KeyEvent.VK_DOWN;
import static java.awt.event.KeyEvent.VK_UP;
public final class TrackEditPanel extends EntityEditPanel {
private final SwingEntityTableModel tableModel;
public TrackEditPanel(SwingEntityEditModel editModel, SwingEntityTableModel tableModel) {
super(editModel);
this.tableModel = tableModel;
addKeyEvents();
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Track.ALBUM_FK);
createForeignKeySearchField(Track.ALBUM_FK);
createTextField(Track.NAME)
.columns(12);
createForeignKeyComboBoxPanel(Track.MEDIATYPE_FK, this::createMediaTypeEditPanel)
.preferredWidth(160)
.includeAddButton(true)
.includeEditButton(true);
createForeignKeyComboBoxPanel(Track.GENRE_FK, this::createGenreEditPanel)
.preferredWidth(160)
.includeAddButton(true)
.includeEditButton(true);
createTextFieldPanel(Track.COMPOSER)
.columns(12);
DurationComponentValue durationValue = createDurationValue();
component(Track.MILLISECONDS).set(durationValue.component());
createIntegerField(Track.BYTES)
.columns(6);
createIntegerSpinner(Track.RATING)
.columns(2);
createTextField(Track.UNITPRICE)
.columns(4);
JPanel genreMediaTypePanel = gridLayoutPanel(1, 2)
.add(createInputPanel(Track.GENRE_FK))
.add(createInputPanel(Track.MEDIATYPE_FK))
.build();
JPanel durationPanel = gridLayoutPanel(1, 2)
.add(createInputPanel(Track.BYTES))
.add(durationValue.component())
.build();
JPanel unitPricePanel = borderLayoutPanel()
.westComponent(createInputPanel(Track.RATING))
.eastComponent(createInputPanel(Track.UNITPRICE))
.build();
setLayout(flexibleGridLayout(4, 2));
addInputPanel(Track.ALBUM_FK);
addInputPanel(Track.NAME);
add(genreMediaTypePanel);
addInputPanel(Track.COMPOSER);
add(durationPanel);
add(unitPricePanel);
}
private EntityEditPanel createMediaTypeEditPanel() {
return new MediaTypeEditPanel(new SwingEntityEditModel(MediaType.TYPE, editModel().connectionProvider()));
}
private GenreEditPanel createGenreEditPanel() {
return new GenreEditPanel(new SwingEntityEditModel(Genre.TYPE, editModel().connectionProvider()));
}
private DurationComponentValue createDurationValue() {
DurationComponentValue durationValue = new DurationComponentValue();
addValidator(Track.MILLISECONDS, durationValue.component().minutesField);
addValidator(Track.MILLISECONDS, durationValue.component().secondsField);
addValidator(Track.MILLISECONDS, durationValue.component().millisecondsField);
durationValue.link(editModel().value(Track.MILLISECONDS));
return durationValue;
}
private void addKeyEvents() {
KeyEvents.builder()
.condition(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
.modifiers(CTRL_DOWN_MASK)
.keyCode(VK_UP)
.action(command(this::moveSelectionUp))
.enable(this)
.keyCode(VK_DOWN)
.action(command(this::moveSelectionDown))
.enable(this);
}
private void moveSelectionUp() {
if (readyForSelectionChange()) {
tableModel.selection().indexes().moveUp();
}
}
private void moveSelectionDown() {
if (readyForSelectionChange()) {
tableModel.selection().indexes().moveDown();
}
}
private boolean readyForSelectionChange() {
// If the selection is empty
if (tableModel.selection().isSelectionEmpty()) {
return true;
}
// If the entity is not modified
if (!editModel().entity().modified().get()) {
return true;
}
// If the current item was modified and
// successfully updated after user confirmation
return updateWithConfirmation();
}
}TrackTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.demos.chinook.model.TrackTableModel;
import is.codion.framework.domain.entity.EntityDefinition;
import is.codion.swing.common.ui.component.spinner.NumberSpinnerBuilder;
import is.codion.swing.common.ui.component.table.FilterTableCellEditor;
import is.codion.swing.common.ui.component.table.FilterTableCellRenderer;
import is.codion.swing.common.ui.component.text.NumberField;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTableCellRenderer;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.component.EntityComponentFactory;
import javax.swing.JSpinner;
import java.math.BigDecimal;
import java.util.Map;
import java.util.Optional;
import java.util.ResourceBundle;
import static is.codion.common.Text.rightPad;
import static is.codion.framework.demos.chinook.ui.DurationComponentValue.minutes;
import static is.codion.framework.demos.chinook.ui.DurationComponentValue.seconds;
import static is.codion.swing.common.ui.component.Components.bigDecimalField;
import static is.codion.swing.common.ui.component.table.FilterTableCellEditor.filterTableCellEditor;
import static is.codion.swing.framework.ui.component.EntityComponents.entityComponents;
import static java.util.ResourceBundle.getBundle;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.toMap;
import static java.util.stream.IntStream.rangeClosed;
public final class TrackTablePanel extends EntityTablePanel {
private static final ResourceBundle BUNDLE = getBundle(TrackTablePanel.class.getName());
static final Map<Integer, String> RATINGS = rangeClosed(1, 10)
.mapToObj(ranking -> rightPad("", ranking, '*'))
.collect(toMap(String::length, identity()));
public TrackTablePanel(TrackTableModel tableModel) {
super(tableModel, config -> config
.editComponentFactory(Track.RATING, new RatingComponentFactory())
.editComponentFactory(Track.MILLISECONDS, new DurationComponentFactory(tableModel))
.cellRenderer(Track.RATING, ratingRenderer(tableModel))
.cellRenderer(Track.MILLISECONDS, durationRenderer(tableModel))
.cellEditor(Track.RATING, ratingEditor(tableModel.entityDefinition()))
.cellEditor(Track.MILLISECONDS, durationEditor())
.includeLimitMenu(true));
configurePopupMenu(config -> config.clear()
.control(Control.builder()
.command(this::raisePriceOfSelected)
.name(BUNDLE.getString("raise_price") + "...")
.enabled(tableModel().selection().empty().not()))
.separator()
.defaults());
}
private void raisePriceOfSelected() throws DatabaseException {
TrackTableModel tableModel = tableModel();
tableModel.raisePriceOfSelected(getAmountFromUser());
}
private BigDecimal getAmountFromUser() {
ComponentValue<BigDecimal, NumberField<BigDecimal>> amountValue =
bigDecimalField()
.nullable(false)
.minimumValue(0)
.buildValue();
return Dialogs.inputDialog(amountValue)
.owner(this)
.title(BUNDLE.getString("amount"))
.validator(amount -> amount.compareTo(BigDecimal.ZERO) > 0)
.show();
}
private static FilterTableCellRenderer<Integer> durationRenderer(SwingEntityTableModel tableModel) {
return EntityTableCellRenderer.builder(Track.MILLISECONDS, tableModel)
.string(milliseconds -> minutes(milliseconds) + " min " + seconds(milliseconds) + " sec")
.toolTipData(true)
.build();
}
private static FilterTableCellEditor<Integer> durationEditor() {
return filterTableCellEditor(() -> new DurationComponentValue(true));
}
private static FilterTableCellRenderer<Integer> ratingRenderer(SwingEntityTableModel tableModel) {
return EntityTableCellRenderer.builder(Track.RATING, tableModel)
.string(RATINGS::get)
.toolTipData(true)
.build();
}
private static FilterTableCellEditor<Integer> ratingEditor(EntityDefinition entityDefinition) {
return filterTableCellEditor(() -> ratingSpinner(entityDefinition).buildValue());
}
private static NumberSpinnerBuilder<Integer> ratingSpinner(EntityDefinition entityDefinition) {
return entityComponents(entityDefinition).integerSpinner(Track.RATING);
}
private static final class RatingComponentFactory
implements EntityComponentFactory<Integer, JSpinner> {
@Override
public ComponentValue<Integer, JSpinner> componentValue(SwingEntityEditModel editModel,
Integer value) {
return ratingSpinner(editModel.entityDefinition())
.value(value)
.buildValue();
}
}
private static final class DurationComponentFactory
implements EntityComponentFactory<Integer, DurationComponentValue.DurationPanel> {
private final String caption;
private DurationComponentFactory(TrackTableModel tableModel) {
this.caption = tableModel.entityDefinition().attributes().definition(Track.MILLISECONDS).caption();
}
@Override
public Optional<String> caption() {
return Optional.of(caption);
}
@Override
public ComponentValue<Integer, DurationComponentValue.DurationPanel> componentValue(SwingEntityEditModel editModel, Integer value) {
DurationComponentValue durationValue = new DurationComponentValue();
durationValue.set(value);
return durationValue;
}
}
}DurationComponentValue
package is.codion.framework.demos.chinook.ui;
import is.codion.swing.common.ui.component.text.NumberField;
import is.codion.swing.common.ui.component.value.AbstractComponentValue;
import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.util.ResourceBundle;
import static is.codion.swing.common.ui.component.Components.*;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.time.Duration.ofMillis;
import static java.time.Duration.ofMinutes;
import static java.util.ResourceBundle.getBundle;
final class DurationComponentValue extends AbstractComponentValue<Integer, DurationComponentValue.DurationPanel> {
DurationComponentValue() {
this(false);
}
DurationComponentValue(boolean cellEditor) {
super(new DurationPanel(cellEditor));
component().minutesField.number().addListener(this::notifyListeners);
component().secondsField.number().addListener(this::notifyListeners);
component().millisecondsField.number().addListener(this::notifyListeners);
}
@Override
protected Integer getComponentValue() {
return (int) ofMinutes(component().minutesField.number().optional().orElse(0))
.plusSeconds(component().secondsField.number().optional().orElse(0))
.plusMillis(component().millisecondsField.number().optional().orElse(0))
.toMillis();
}
@Override
protected void setComponentValue(Integer milliseconds) {
component().minutesField.number().set(minutes(milliseconds));
component().secondsField.number().set(seconds(milliseconds));
component().millisecondsField.number().set(milliseconds(milliseconds));
}
static Integer minutes(Integer milliseconds) {
if (milliseconds == null) {
return null;
}
return (int) ofMillis(milliseconds).toMinutes();
}
static Integer seconds(Integer milliseconds) {
if (milliseconds == null) {
return null;
}
return (int) ofMillis(milliseconds)
.minusMinutes(ofMillis(milliseconds).toMinutes())
.getSeconds();
}
static Integer milliseconds(Integer milliseconds) {
if (milliseconds == null) {
return null;
}
return (int) ofMillis(milliseconds)
.minusSeconds(ofMillis(milliseconds).toSeconds())
.toMillis();
}
static final class DurationPanel extends JPanel {
private static final ResourceBundle BUNDLE = getBundle(DurationPanel.class.getName());
final NumberField<Integer> minutesField;
final NumberField<Integer> secondsField;
final NumberField<Integer> millisecondsField;
private DurationPanel(boolean cellEditor) {
super(borderLayout());
minutesField = integerField()
.transferFocusOnEnter(true)
.selectAllOnFocusGained(true)
.columns(2)
.build();
secondsField = integerField()
.valueRange(0, 59)
.transferFocusOnEnter(true)
.selectAllOnFocusGained(true)
.silentValidation(true)
.columns(2)
.build();
millisecondsField = integerField()
.valueRange(0, 999)
.transferFocusOnEnter(!cellEditor)
.selectAllOnFocusGained(true)
.silentValidation(true)
.columns(3)
.build();
if (cellEditor) {
initializeCellEditor();
}
else {
initializeInputPanel();
}
addFocusListener(new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
minutesField.requestFocusInWindow();
}
});
}
private void initializeCellEditor() {
add(flexibleGridLayoutPanel(1, 3)
.add(minutesField)
.add(secondsField)
.add(millisecondsField)
.build(), BorderLayout.CENTER);
}
private void initializeInputPanel() {
add(borderLayoutPanel()
.northComponent(gridLayoutPanel(1, 3)
.add(new JLabel(BUNDLE.getString("min")))
.add(new JLabel(BUNDLE.getString("sec")))
.add(new JLabel(BUNDLE.getString("ms")))
.build())
.centerComponent(gridLayoutPanel(1, 2)
.add(minutesField)
.add(secondsField)
.add(millisecondsField)
.build())
.build());
}
}
}Playlists
Playlist
SQL
CREATE TABLE CHINOOK.PLAYLIST
(
PLAYLISTID LONG GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(120) NOT NULL,
CONSTRAINT PK_PLAYLIST PRIMARY KEY (PLAYLISTID),
CONSTRAINT UK_PLAYLIST UNIQUE (NAME)
);Domain
API
interface Playlist {
EntityType TYPE = DOMAIN.entityType("playlist@chinook", Playlist.class.getName());
Column<Long> ID = TYPE.longColumn("playlistid");
Column<String> NAME = TYPE.stringColumn("name");
FunctionType<EntityConnection, RandomPlaylistParameters, Entity> RANDOM_PLAYLIST = functionType("chinook.random_playlist");
record RandomPlaylistParameters(String playlistName, Integer noOfTracks, Collection<Entity> genres) implements Serializable {}
}Implementation
EntityDefinition playlist() {
return Playlist.TYPE.define(
Playlist.ID.define()
.primaryKey(),
Playlist.NAME.define()
.column()
.searchable(true)
.nullable(false)
.maximumLength(120))
.tableName("chinook.playlist")
.keyGenerator(identity())
.orderBy(ascending(Playlist.NAME))
.stringFactory(Playlist.NAME)
.build();
}CreateRandomPlaylistFunction
private static final class CreateRandomPlaylistFunction implements DatabaseFunction<EntityConnection, RandomPlaylistParameters, Entity> {
private final Entities entities;
private CreateRandomPlaylistFunction(Entities entities) {
this.entities = entities;
}
@Override
public Entity execute(EntityConnection connection,
RandomPlaylistParameters parameters) throws DatabaseException {
List<Long> trackIds = randomTrackIds(connection, parameters.noOfTracks(), parameters.genres());
return insertPlaylist(connection, parameters.playlistName(), trackIds);
}
private Entity insertPlaylist(EntityConnection connection, String playlistName,
List<Long> trackIds) throws DatabaseException {
Entity playlist = connection.insertSelect(createPlaylist(playlistName));
connection.insert(createPlaylistTracks(playlist.primaryKey().get(), trackIds));
return playlist;
}
private Entity createPlaylist(String playlistName) {
return entities.builder(Playlist.TYPE)
.with(Playlist.NAME, playlistName)
.build();
}
private List<Entity> createPlaylistTracks(Long playlistId, List<Long> trackIds) {
return trackIds.stream()
.map(trackId -> createPlaylistTrack(playlistId, trackId))
.toList();
}
private Entity createPlaylistTrack(Long playlistId, Long trackId) {
return entities.builder(PlaylistTrack.TYPE)
.with(PlaylistTrack.PLAYLIST_ID, playlistId)
.with(PlaylistTrack.TRACK_ID, trackId)
.build();
}
private static List<Long> randomTrackIds(EntityConnection connection, int noOfTracks,
Collection<Entity> genres) throws DatabaseException {
return connection.select(Track.ID,
where(Track.GENRE_FK.in(genres))
.orderBy(ascending(Track.RANDOM))
.limit(noOfTracks)
.build());
}
}Model
PlaylistEditModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityEditModel;
import java.util.Collection;
import static is.codion.framework.db.EntityConnection.transaction;
import static is.codion.framework.domain.entity.Entity.primaryKeys;
public final class PlaylistEditModel extends SwingEntityEditModel {
public PlaylistEditModel(EntityConnectionProvider connectionProvider) {
super(Playlist.TYPE, connectionProvider);
}
@Override
protected void delete(Collection<Entity> playlists, EntityConnection connection) throws DatabaseException {
transaction(connection, () -> {
connection.delete(PlaylistTrack.PLAYLIST_FK.in(playlists));
connection.delete(primaryKeys(playlists));
});
}
}PlaylistTableModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityTableModel;
import static is.codion.framework.db.EntityConnection.transaction;
public final class PlaylistTableModel extends SwingEntityTableModel {
public PlaylistTableModel(EntityConnectionProvider connectionProvider) {
super(new PlaylistEditModel(connectionProvider));
}
public void createRandomPlaylist(RandomPlaylistParameters parameters) throws DatabaseException {
EntityConnection connection = connection();
Entity randomPlaylist = transaction(connection, () -> connection.execute(Playlist.RANDOM_PLAYLIST, parameters));
items().visible().addItemAt(0, randomPlaylist);
selection().item().set(randomPlaylist);
}
}UI
PlaylistPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;
import java.awt.BorderLayout;
import static is.codion.swing.common.ui.component.Components.splitPane;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
public final class PlaylistPanel extends EntityPanel {
public PlaylistPanel(SwingEntityModel playlistModel) {
super(playlistModel,
new PlaylistTablePanel(playlistModel.tableModel()),
config -> config.detailLayout(DetailLayout.NONE));
SwingEntityModel playlistTrackModel = playlistModel.detailModel(PlaylistTrack.TYPE);
EntityPanel playlistTrackPanel = new EntityPanel(playlistTrackModel,
new PlaylistTrackTablePanel(playlistTrackModel.tableModel()));
addDetailPanel(playlistTrackPanel);
}
@Override
protected void initializeUI() {
setLayout(borderLayout());
add(splitPane()
.leftComponent(mainPanel())
.rightComponent(detailPanel(PlaylistTrack.TYPE).initialize())
.continuousLayout(true)
.build(), BorderLayout.CENTER);
}
}PlaylistEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.swing.common.ui.layout.Layouts;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.border.EmptyBorder;
import java.awt.BorderLayout;
import static is.codion.swing.common.ui.component.Components.borderLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
final class PlaylistEditPanel extends EntityEditPanel {
PlaylistEditPanel(SwingEntityEditModel editModel) {
super(editModel, config -> config.updateConfirmer(Confirmer.NONE));
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(Playlist.NAME);
createTextField(Playlist.NAME)
.transferFocusOnEnter(false)
.columns(20);
setLayout(borderLayout());
add(borderLayoutPanel()
.westComponent(createLabel(Playlist.NAME).build())
.centerComponent(component(Playlist.NAME).get())
.border(new EmptyBorder(Layouts.GAP.get(), Layouts.GAP.get(), 0, Layouts.GAP.get()))
.build(), BorderLayout.CENTER);
}
}PlaylistTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.demos.chinook.model.PlaylistTableModel;
import is.codion.swing.common.ui.component.value.AbstractComponentValue;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.icon.FrameworkIcons;
import java.util.ResourceBundle;
import static is.codion.swing.framework.ui.EntityTablePanel.ControlKeys.DELETE;
import static is.codion.swing.framework.ui.EntityTablePanel.ControlKeys.EDIT_ATTRIBUTE_CONTROLS;
import static java.util.ResourceBundle.getBundle;
public final class PlaylistTablePanel extends EntityTablePanel {
private static final ResourceBundle BUNDLE = getBundle(PlaylistTablePanel.class.getName());
public PlaylistTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, new PlaylistEditPanel(tableModel.editModel()));
configurePopupMenu(config -> config.clear()
.defaults(DELETE)
.separator()
.control(Control.builder()
.command(this::randomPlaylist)
.name(BUNDLE.getString("random_playlist"))
.smallIcon(FrameworkIcons.instance().add()))
.separator()
.defaults());
}
@Override
protected void setupControls() {
// No need for the edit value controls in the popup menu
control(EDIT_ATTRIBUTE_CONTROLS).clear();
}
private void randomPlaylist() throws DatabaseException {
RandomPlaylistParametersValue playlistParametersValue = new RandomPlaylistParametersValue(tableModel().connectionProvider());
RandomPlaylistParameters randomPlaylistParameters = Dialogs.inputDialog(playlistParametersValue)
.owner(this)
.title(BUNDLE.getString("random_playlist"))
.valid(playlistParametersValue.component().parametersValid())
.show();
PlaylistTableModel playlistTableModel = tableModel();
playlistTableModel.createRandomPlaylist(randomPlaylistParameters);
}
private static final class RandomPlaylistParametersValue
extends AbstractComponentValue<RandomPlaylistParameters, RandomPlaylistParametersPanel> {
private RandomPlaylistParametersValue(EntityConnectionProvider connectionProvider) {
super(new RandomPlaylistParametersPanel(connectionProvider));
}
@Override
protected RandomPlaylistParameters getComponentValue() {
return component().get();
}
@Override
protected void setComponentValue(RandomPlaylistParameters parameters) {/* Read only value, not required */}
}
}RandomPlaylistParametersPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.state.State;
import is.codion.common.state.StateObserver;
import is.codion.common.value.Value;
import is.codion.common.value.ValueList;
import is.codion.framework.db.EntityConnection.Select;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.component.Components;
import is.codion.swing.common.ui.component.text.NumberField;
import javax.swing.DefaultListModel;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import java.awt.BorderLayout;
import java.util.ResourceBundle;
import static is.codion.common.Text.nullOrEmpty;
import static is.codion.framework.domain.entity.OrderBy.ascending;
import static is.codion.swing.common.ui.component.Components.*;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.util.ResourceBundle.getBundle;
final class RandomPlaylistParametersPanel extends JPanel {
private static final ResourceBundle BUNDLE = getBundle(RandomPlaylistParametersPanel.class.getName());
private final RandomPlaylistParametersModel model = new RandomPlaylistParametersModel();
private final JTextField playlistNameField;
private final NumberField<Integer> noOfTracksField;
private final JList<Entity> genreList;
RandomPlaylistParametersPanel(EntityConnectionProvider connectionProvider) {
super(borderLayout());
playlistNameField = createPlaylistNameField();
noOfTracksField = createNoOfTracksField();
genreList = createGenreList(connectionProvider);
add(borderLayoutPanel()
.northComponent(gridLayoutPanel(1, 2)
.add(new JLabel(BUNDLE.getString("playlist_name")))
.add(new JLabel(BUNDLE.getString("no_of_tracks")))
.build())
.centerComponent(gridLayoutPanel(1, 2)
.add(playlistNameField)
.add(noOfTracksField)
.build())
.southComponent(borderLayoutPanel()
.northComponent(new JLabel(BUNDLE.getString("genres")))
.centerComponent(new JScrollPane(genreList))
.build())
.build(), BorderLayout.CENTER);
}
StateObserver parametersValid() {
return model.parametersValid.observer();
}
RandomPlaylistParameters get() {
return new RandomPlaylistParameters(model.playlistName.get(), model.noOfTracks.get(), model.genres.get());
}
private JTextField createPlaylistNameField() {
return stringField(model.playlistName)
.transferFocusOnEnter(true)
.selectAllOnFocusGained(true)
.maximumLength(120)
.columns(10)
.build();
}
private NumberField<Integer> createNoOfTracksField() {
return integerField(model.noOfTracks)
.valueRange(1, 5000)
.transferFocusOnEnter(true)
.selectAllOnFocusGained(true)
.columns(3)
.build();
}
private JList<Entity> createGenreList(EntityConnectionProvider connectionProvider) {
return Components.list(createGenreListModel(connectionProvider))
.selectedItems(model.genres)
.visibleRowCount(5)
.build();
}
private static DefaultListModel<Entity> createGenreListModel(EntityConnectionProvider connectionProvider) {
DefaultListModel<Entity> listModel = new DefaultListModel<>();
try {
connectionProvider.connection().select(Select.all(Genre.TYPE)
.orderBy(ascending(Genre.NAME))
.build())
.forEach(listModel::addElement);
return listModel;
}
catch (DatabaseException e) {
throw new RuntimeException(e);
}
}
private static final class RandomPlaylistParametersModel {
private final Value<String> playlistName = Value.value();
private final Value<Integer> noOfTracks = Value.value();
private final ValueList<Entity> genres = ValueList.valueList();
private final State parametersValid = State.state();
private RandomPlaylistParametersModel() {
playlistName.addListener(this::validate);
noOfTracks.addListener(this::validate);
genres.addListener(this::validate);
validate();
}
private void validate() {
parametersValid.set(isValid());
}
private boolean isValid() {
if (nullOrEmpty(playlistName.get())) {
return false;
}
if (noOfTracks.isNull()) {
return false;
}
if (genres.empty()) {
return false;
}
return true;
}
}
}Playlist Track
SQL
CREATE TABLE CHINOOK.PLAYLISTTRACK
(
PLAYLISTTRACKID LONG GENERATED BY DEFAULT AS IDENTITY,
PLAYLISTID INTEGER NOT NULL,
TRACKID INTEGER NOT NULL,
CONSTRAINT PK_PLAYLISTTRACK PRIMARY KEY (PLAYLISTTRACKID),
CONSTRAINT UK_PLAYLISTTRACK UNIQUE (PLAYLISTID, TRACKID),
CONSTRAINT FK_TRACK_PLAYLISTTRACK FOREIGN KEY (TRACKID) REFERENCES CHINOOK.TRACK(TRACKID),
CONSTRAINT FK_PLAYLIST_PLAYLISTTRACK FOREIGN KEY (PLAYLISTID) REFERENCES CHINOOK.PLAYLIST(PLAYLISTID)
);Domain
API
interface PlaylistTrack {
EntityType TYPE = DOMAIN.entityType("playlisttrack@chinook", PlaylistTrack.class.getName());
Column<Long> ID = TYPE.longColumn("playlisttrackid");
Column<Long> PLAYLIST_ID = TYPE.longColumn("playlistid");
Column<Long> TRACK_ID = TYPE.longColumn("trackid");
Attribute<Entity> ALBUM = TYPE.entityAttribute("album");
Attribute<Entity> ARTIST = TYPE.entityAttribute("artist");
ForeignKey PLAYLIST_FK = TYPE.foreignKey("playlist_fk", PLAYLIST_ID, Playlist.ID);
ForeignKey TRACK_FK = TYPE.foreignKey("track_fk", TRACK_ID, Track.ID);
}Implementation
EntityDefinition playlistTrack() {
return PlaylistTrack.TYPE.define(
PlaylistTrack.ID.define()
.primaryKey(),
PlaylistTrack.PLAYLIST_ID.define()
.column()
.nullable(false),
PlaylistTrack.PLAYLIST_FK.define()
.foreignKey(),
PlaylistTrack.ARTIST.define()
.denormalized(PlaylistTrack.ALBUM, Album.ARTIST_FK),
PlaylistTrack.TRACK_ID.define()
.column()
.nullable(false),
PlaylistTrack.TRACK_FK.define()
.foreignKey(3),
PlaylistTrack.ALBUM.define()
.denormalized(PlaylistTrack.TRACK_FK, Track.ALBUM_FK))
.tableName("chinook.playlisttrack")
.keyGenerator(identity())
.stringFactory(StringFactory.builder()
.value(PlaylistTrack.PLAYLIST_FK)
.text(" - ")
.value(PlaylistTrack.TRACK_FK)
.build())
.build();
}Model
PlaylistTrackEditModel
package is.codion.framework.demos.chinook.model;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.condition.Condition;
import is.codion.swing.framework.model.SwingEntityEditModel;
import java.util.List;
public final class PlaylistTrackEditModel extends SwingEntityEditModel {
public PlaylistTrackEditModel(EntityConnectionProvider connectionProvider) {
super(PlaylistTrack.TYPE, connectionProvider);
value(PlaylistTrack.TRACK_FK).persist().set(false);
// Filter out tracks already in the current playlist
value(PlaylistTrack.PLAYLIST_FK).addConsumer(this::filterPlaylistTracks);
}
private void filterPlaylistTracks(Entity playlist) {
foreignKeySearchModel(PlaylistTrack.TRACK_FK).condition().set(() -> playlist == null ? null :
Condition.custom(Track.NOT_IN_PLAYLIST,
List.of(Playlist.ID),
List.of(playlist.get(Playlist.ID))));
}
}UI
PlaylistTrackEditPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.demos.chinook.model.PlaylistTrackEditModel;
import is.codion.swing.common.ui.layout.Layouts;
import is.codion.swing.framework.ui.EntityEditPanel;
import javax.swing.border.EmptyBorder;
import java.awt.BorderLayout;
import static is.codion.swing.common.ui.component.Components.borderLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
final class PlaylistTrackEditPanel extends EntityEditPanel {
PlaylistTrackEditPanel(PlaylistTrackEditModel editModel) {
super(editModel, config -> config
// Skip confirmation when deleting
.deleteConfirmer(Confirmer.NONE));
}
@Override
protected void initializeUI() {
initialFocusAttribute().set(PlaylistTrack.TRACK_FK);
createForeignKeySearchField(PlaylistTrack.TRACK_FK)
.selectorFactory(new TrackSelectorFactory())
.transferFocusOnEnter(false)
.columns(25);
setLayout(borderLayout());
add(borderLayoutPanel()
.westComponent(createLabel(PlaylistTrack.TRACK_FK).build())
.centerComponent(component(PlaylistTrack.TRACK_FK).get())
.border(new EmptyBorder(Layouts.GAP.get(), Layouts.GAP.get(), 0, Layouts.GAP.get()))
.build(), BorderLayout.CENTER);
}
}PlaylistTrackTablePanel
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.component.table.ColumnConditionPanel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityEditPanel.Confirmer;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.component.EntitySearchField;
import java.util.Optional;
import java.util.stream.Stream;
public final class PlaylistTrackTablePanel extends EntityTablePanel {
public PlaylistTrackTablePanel(SwingEntityTableModel tableModel) {
super(tableModel, new PlaylistTrackEditPanel(tableModel.editModel()), config -> config
.editComponentFactory(PlaylistTrack.TRACK_FK, new TrackComponentFactory(PlaylistTrack.TRACK_FK))
// Skip confirmation when deleting
.deleteConfirmer(Confirmer.NONE)
.includeEditControl(false));
table().columnModel()
.visible().set(PlaylistTrack.TRACK_FK, PlaylistTrack.ARTIST, PlaylistTrack.ALBUM);
configureTrackConditionPanel();
}
private void configureTrackConditionPanel() {
ColumnConditionPanel<Entity> conditionPanel = conditions().get(PlaylistTrack.TRACK_FK);
Stream.of(conditionPanel.fields().equal(), conditionPanel.fields().in())
.flatMap(Optional::stream)
.map(EntitySearchField.class::cast)
.forEach(field -> field.selectorFactory().set(new TrackSelectorFactory()));
}
}TrackComponentFactory
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.ForeignKey;
import is.codion.swing.common.ui.component.value.ComponentValue;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.component.DefaultEntityComponentFactory;
import is.codion.swing.framework.ui.component.EntitySearchField;
final class TrackComponentFactory extends DefaultEntityComponentFactory<Entity, EntitySearchField> {
TrackComponentFactory(ForeignKey trackForeignKey) {
super(trackForeignKey);
}
@Override
public ComponentValue<Entity, EntitySearchField> componentValue(SwingEntityEditModel editModel,
Entity value) {
ComponentValue<Entity, EntitySearchField> componentValue = super.componentValue(editModel, value);
EntitySearchField trackSearchField = componentValue.component();
trackSearchField.selectorFactory().set(new TrackSelectorFactory());
return componentValue;
}
}TrackSelectorFactory
package is.codion.framework.demos.chinook.ui;
import is.codion.framework.model.EntitySearchModel;
import is.codion.swing.framework.ui.component.EntitySearchField.Selector;
import is.codion.swing.framework.ui.component.EntitySearchField.TableSelector;
import java.awt.Dimension;
import java.util.function.Function;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import static is.codion.swing.framework.ui.component.EntitySearchField.tableSelector;
import static javax.swing.SortOrder.ASCENDING;
final class TrackSelectorFactory implements Function<EntitySearchModel, Selector> {
@Override
public TableSelector apply(EntitySearchModel searchModel) {
TableSelector selector = tableSelector(searchModel);
selector.table().columnModel().visible().set(Track.ARTIST, Track.ALBUM_FK, Track.NAME);
selector.table().model().sorter().setSortOrder(Track.ARTIST, ASCENDING);
selector.table().model().sorter().addSortOrder(Track.ALBUM_FK, ASCENDING);
selector.table().model().sorter().addSortOrder(Track.NAME, ASCENDING);
selector.preferredSize(new Dimension(500, 300));
return selector;
}
}Application
ChinookAppModel
package is.codion.framework.demos.chinook.model;
import is.codion.common.version.Version;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.model.ForeignKeyDetailModelLink;
import is.codion.swing.framework.model.SwingEntityApplicationModel;
import is.codion.swing.framework.model.SwingEntityModel;
import static is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
public final class ChinookAppModel extends SwingEntityApplicationModel {
public static final Version VERSION = Version.parse(ChinookAppModel.class, "/version.properties");
public ChinookAppModel(EntityConnectionProvider connectionProvider) {
super(connectionProvider, VERSION);
addEntityModel(createAlbumModel(connectionProvider));
addEntityModel(createPlaylistModel(connectionProvider));
addEntityModel(createCustomerModel(connectionProvider));
}
private static SwingEntityModel createAlbumModel(EntityConnectionProvider connectionProvider) {
AlbumModel albumModel = new AlbumModel(connectionProvider);
albumModel.tableModel().refresh();
return albumModel;
}
private static SwingEntityModel createPlaylistModel(EntityConnectionProvider connectionProvider) {
SwingEntityModel playlistModel = new SwingEntityModel(new PlaylistTableModel(connectionProvider));
SwingEntityModel playlistTrackModel = new SwingEntityModel(new PlaylistTrackEditModel(connectionProvider));
ForeignKeyDetailModelLink<?, ?, ?> playlistTrackLink =
playlistModel.addDetailModel(playlistTrackModel);
playlistTrackLink.clearForeignKeyValueOnEmptySelection().set(true);
playlistTrackLink.active().set(true);
playlistModel.tableModel().refresh();
return playlistModel;
}
private static SwingEntityModel createCustomerModel(EntityConnectionProvider connectionProvider) {
SwingEntityModel customerModel = new SwingEntityModel(Customer.TYPE, connectionProvider);
customerModel.editModel().initializeComboBoxModels(Customer.SUPPORTREP_FK);
SwingEntityModel invoiceModel = new InvoiceModel(connectionProvider);
customerModel.addDetailModel(invoiceModel);
customerModel.tableModel().refresh();
return customerModel;
}
}UI
ChinookAppPanel
package is.codion.framework.demos.chinook.ui;
import is.codion.common.model.CancelException;
import is.codion.common.model.UserPreferences;
import is.codion.common.user.User;
import is.codion.framework.demos.chinook.model.ChinookAppModel;
import is.codion.framework.demos.chinook.model.TrackTableModel;
import is.codion.swing.common.ui.component.combobox.Completion;
import is.codion.swing.common.ui.component.table.FilterTable;
import is.codion.swing.common.ui.component.table.FilterTableCellRenderer;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.laf.LookAndFeelProvider;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityApplicationPanel;
import is.codion.swing.framework.ui.EntityEditPanel;
import is.codion.swing.framework.ui.EntityPanel;
import is.codion.swing.framework.ui.EntityPanel.WindowType;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.ReferentialIntegrityErrorHandling;
import is.codion.swing.framework.ui.TabbedDetailLayout;
import is.codion.swing.framework.ui.icon.FrameworkIcons;
import com.formdev.flatlaf.intellijthemes.FlatAllIJThemes;
import org.kordamp.ikonli.foundation.Foundation;
import javax.swing.ButtonGroup;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import java.awt.Dimension;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Optional;
import java.util.ResourceBundle;
import static is.codion.framework.demos.chinook.domain.api.Chinook.*;
import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.component.Components.radioButton;
import static is.codion.swing.common.ui.key.KeyEvents.keyStroke;
import static is.codion.swing.framework.ui.EntityPanel.PanelState.HIDDEN;
import static java.awt.event.InputEvent.CTRL_DOWN_MASK;
import static java.util.ResourceBundle.getBundle;
import static javax.swing.JOptionPane.showMessageDialog;
public final class ChinookAppPanel extends EntityApplicationPanel<ChinookAppModel> {
private static final String DEFAULT_FLAT_LOOK_AND_FEEL = "com.formdev.flatlaf.intellijthemes.materialthemeuilite.FlatMaterialDarkerIJTheme";
private static final String LANGUAGE_PREFERENCES_KEY = ChinookAppPanel.class.getSimpleName() + ".language";
private static final String LANGUAGE_IS = "is";
private static final String LANGUAGE_EN = "en";
private static final Locale LOCALE_IS = new Locale(LANGUAGE_IS, "IS");
private static final Locale LOCALE_EN = new Locale(LANGUAGE_EN, "EN");
private static final String SELECT_LANGUAGE = "select_language";
/* Non-static so this is not initialized before main(), which sets the locale */
private final ResourceBundle bundle = getBundle(ChinookAppPanel.class.getName());
public ChinookAppPanel(ChinookAppModel appModel) {
super(appModel);
}
@Override
protected List<EntityPanel> createEntityPanels() {
return List.of(
new CustomerPanel(applicationModel().entityModel(Customer.TYPE)),
new AlbumPanel(applicationModel().entityModel(Album.TYPE)),
new PlaylistPanel(applicationModel().entityModel(Playlist.TYPE))
);
}
@Override
protected List<EntityPanel.Builder> createSupportEntityPanelBuilders() {
EntityPanel.Builder trackPanelBuilder =
EntityPanel.builder(Track.TYPE)
.tablePanel(TrackTablePanel.class);
SwingEntityModel.Builder genreModelBuilder =
SwingEntityModel.builder(Genre.TYPE)
.detailModel(SwingEntityModel.builder(Track.TYPE)
.tableModel(TrackTableModel.class));
EntityPanel.Builder genrePanelBuilder =
EntityPanel.builder(genreModelBuilder)
.editPanel(GenreEditPanel.class)
.detailPanel(trackPanelBuilder)
.detailLayout(entityPanel -> TabbedDetailLayout.builder(entityPanel)
.initialDetailState(HIDDEN)
.build());
EntityPanel.Builder mediaTypePanelBuilder =
EntityPanel.builder(MediaType.TYPE)
.editPanel(MediaTypeEditPanel.class);
EntityPanel.Builder artistPanelBuilder =
EntityPanel.builder(Artist.TYPE)
.editPanel(ArtistEditPanel.class);
EntityPanel.Builder customerPanelBuilder =
EntityPanel.builder(Customer.TYPE)
.tablePanel(CustomerTablePanel.class);
SwingEntityModel.Builder employeeModelBuilder =
SwingEntityModel.builder(Employee.TYPE)
.detailModel(SwingEntityModel.builder(Customer.TYPE));
EntityPanel.Builder employeePanelBuilder =
EntityPanel.builder(employeeModelBuilder)
.tablePanel(EmployeeTablePanel.class)
.detailPanel(customerPanelBuilder)
.detailLayout(entityPanel -> TabbedDetailLayout.builder(entityPanel)
.initialDetailState(HIDDEN)
.build())
.preferredSize(new Dimension(1000, 500));
return List.of(artistPanelBuilder, genrePanelBuilder, mediaTypePanelBuilder, employeePanelBuilder);
}
@Override
protected Optional<Controls> createViewMenuControls() {
return super.createViewMenuControls()
.map(controls -> controls.copy()
.controlAt(2, Control.builder()
.command(this::selectLanguage)
.name(bundle.getString(SELECT_LANGUAGE))
.build())
.build());
}
private void selectLanguage() {
String currentLanguage = UserPreferences.getUserPreference(LANGUAGE_PREFERENCES_KEY, Locale.getDefault().getLanguage());
JPanel languagePanel = gridLayoutPanel(2, 1).build();
ButtonGroup buttonGroup = new ButtonGroup();
radioButton()
.text(bundle.getString("english"))
.selected(currentLanguage.equals(LANGUAGE_EN))
.buttonGroup(buttonGroup)
.build(languagePanel::add);
JRadioButton isButton = radioButton()
.text(bundle.getString("icelandic"))
.selected(currentLanguage.equals(LANGUAGE_IS))
.buttonGroup(buttonGroup)
.build(languagePanel::add);
showMessageDialog(this, languagePanel, bundle.getString("language"), JOptionPane.QUESTION_MESSAGE);
String selectedLanguage = isButton.isSelected() ? LANGUAGE_IS : LANGUAGE_EN;
if (!currentLanguage.equals(selectedLanguage)) {
UserPreferences.setUserPreference(LANGUAGE_PREFERENCES_KEY, selectedLanguage);
showMessageDialog(this, bundle.getString("language_has_been_changed"));
}
}
public static void main(String[] args) throws CancelException {
String language = UserPreferences.getUserPreference(LANGUAGE_PREFERENCES_KEY, Locale.getDefault().getLanguage());
Locale.setDefault(LANGUAGE_IS.equals(language) ? LOCALE_IS : LOCALE_EN);
Arrays.stream(FlatAllIJThemes.INFOS).forEach(LookAndFeelProvider::addLookAndFeel);
FrameworkIcons.instance().add(Foundation.PLUS, Foundation.MINUS);
Completion.COMBO_BOX_COMPLETION_MODE.set(Completion.Mode.AUTOCOMPLETE);
EntityPanel.Config.TOOLBAR_CONTROLS.set(true);
EntityPanel.Config.WINDOW_TYPE.set(WindowType.FRAME);
EntityEditPanel.Config.MODIFIED_WARNING.set(true);
// Add a CTRL modifier to the DELETE key shortcut for table panels
EntityTablePanel.ControlKeys.DELETE.defaultKeystroke()
.map(keyStroke -> keyStroke(keyStroke.getKeyCode(), CTRL_DOWN_MASK));
EntityTablePanel.Config.COLUMN_SELECTION.set(EntityTablePanel.ColumnSelection.MENU);
EntityTablePanel.Config.INCLUDE_FILTERS.set(true);
FilterTable.AUTO_RESIZE_MODE.set(JTable.AUTO_RESIZE_ALL_COLUMNS);
FilterTableCellRenderer.NUMERICAL_HORIZONTAL_ALIGNMENT.set(SwingConstants.CENTER);
FilterTableCellRenderer.TEMPORAL_HORIZONTAL_ALIGNMENT.set(SwingConstants.CENTER);
ReferentialIntegrityErrorHandling.REFERENTIAL_INTEGRITY_ERROR_HANDLING.set(ReferentialIntegrityErrorHandling.DISPLAY_DEPENDENCIES);
EntityApplicationPanel.builder(ChinookAppModel.class, ChinookAppPanel.class)
.applicationName("Chinook")
.domainType(DOMAIN)
.applicationVersion(ChinookAppModel.VERSION)
.defaultLookAndFeelClassName(DEFAULT_FLAT_LOOK_AND_FEEL)
.defaultLoginUser(User.parse("scott:tiger"))
.displayStartupDialog(false)
.start();
}
}Messages
ChinookResources
package is.codion.framework.demos.chinook.domain;
import is.codion.common.resource.Resources;
import is.codion.framework.i18n.FrameworkMessages;
import java.util.Locale;
/**
* Replace the english insert caption/mnemonic Add/A with Insert/I.
*/
public final class ChinookResources implements Resources {
private static final String FRAMEWORK_MESSAGES =
FrameworkMessages.class.getName();
private final boolean english = Locale.getDefault()
.equals(new Locale("en", "EN"));
@Override
public String getString(String baseBundleName, String key, String defaultString) {
if (english && baseBundleName.equals(FRAMEWORK_MESSAGES)) {
return switch (key) {
case "insert" -> "Insert";
case "insert_mnemonic" -> "I";
default -> defaultString;
};
}
return defaultString;
}
}Authenticator
SQL
CREATE TABLE CHINOOK.USERS
(
USERID LONG GENERATED BY DEFAULT AS IDENTITY,
USERNAME VARCHAR(20) NOT NULL,
PASSWORDHASH INTEGER NOT NULL,
CONSTRAINT PK_USER PRIMARY KEY (USERID),
CONSTRAINT UK_USER UNIQUE (USERNAME)
);ChinookAuthenticator
package is.codion.framework.demos.chinook.server;
import is.codion.common.db.database.Database;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.db.pool.ConnectionPoolFactory;
import is.codion.common.db.pool.ConnectionPoolWrapper;
import is.codion.common.rmi.server.Authenticator;
import is.codion.common.rmi.server.RemoteClient;
import is.codion.common.rmi.server.exception.LoginException;
import is.codion.common.rmi.server.exception.ServerAuthenticationException;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.domain.Domain;
import is.codion.framework.domain.DomainModel;
import is.codion.framework.domain.DomainType;
import is.codion.framework.domain.entity.EntityType;
import is.codion.framework.domain.entity.attribute.Column;
import java.util.Optional;
import static is.codion.framework.db.EntityConnection.Count.where;
import static is.codion.framework.db.local.LocalEntityConnection.localEntityConnection;
import static is.codion.framework.domain.DomainType.domainType;
import static is.codion.framework.domain.entity.condition.Condition.and;
import static java.lang.String.valueOf;
/**
* A {@link is.codion.common.rmi.server.Authenticator} implementation
* authenticating via a user lookup table.
*/
public final class ChinookAuthenticator implements Authenticator {
/**
* The Database instance we're connecting to.
*/
private final Database database = Database.instance();
/**
* The actual user credentials to return for successfully authenticated users.
*/
private final User databaseUser = User.parse("scott:tiger");
/**
* The Domain containing the authentication table.
*/
private final Domain domain = new Authentication();
/**
* The ConnectionPool used when authenticating users.
*/
private final ConnectionPoolWrapper connectionPool;
/**
* The user used for authenticating.
*/
private final User authenticationUser = User.user("sa");
public ChinookAuthenticator() throws DatabaseException {
connectionPool = ConnectionPoolFactory.instance().createConnectionPool(database, authenticationUser);
}
/**
* Handles logins from clients with this id
*/
@Override
public Optional<String> clientTypeId() {
return Optional.of("is.codion.framework.demos.chinook.ui.ChinookAppPanel");
}
@Override
public RemoteClient login(RemoteClient remoteClient) throws LoginException {
authenticateUser(remoteClient.user());
//Create a new RemoteClient based on the one received
//but with the actual database user
return remoteClient.withDatabaseUser(databaseUser);
}
@Override
public void close() {
connectionPool.close();
}
private void authenticateUser(User user) throws LoginException {
try (EntityConnection connection = fetchConnectionFromPool()) {
int rows = connection.count(where(and(
Authentication.User.USERNAME
.equalToIgnoreCase(user.username()),
Authentication.User.PASSWORD_HASH
.equalTo(valueOf(user.password()).hashCode()))));
if (rows == 0) {
throw new ServerAuthenticationException("Wrong username or password");
}
}
catch (DatabaseException e) {
throw new RuntimeException(e);
}
}
private EntityConnection fetchConnectionFromPool() throws DatabaseException {
return localEntityConnection(database, domain, connectionPool.connection(authenticationUser));
}
private static final class Authentication extends DomainModel {
private static final DomainType DOMAIN = domainType(Authentication.class);
interface User {
EntityType TYPE = DOMAIN.entityType("chinook.users");
Column<Integer> ID = TYPE.integerColumn("userid");
Column<String> USERNAME = TYPE.stringColumn("username");
Column<Integer> PASSWORD_HASH = TYPE.integerColumn("passwordhash");
}
private Authentication() {
super(DOMAIN);
add(User.TYPE.define(
User.ID.define()
.primaryKey(),
User.USERNAME.define()
.column(),
User.PASSWORD_HASH.define()
.column())
.readOnly(true)
.build());
}
}
}Domain unit test
package is.codion.framework.demos.chinook.domain;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.framework.domain.test.DefaultEntityFactory;
import is.codion.framework.domain.test.DomainTest;
import org.junit.jupiter.api.Test;
import java.util.List;
import static is.codion.framework.demos.chinook.domain.api.Chinook.*;
import static java.util.Arrays.asList;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class ChinookTest extends DomainTest {
public ChinookTest() {
super(new ChinookImpl(), ChinookEntityFactory::new);
}
@Test
void album() throws Exception {
test(Album.TYPE);
}
@Test
void artist() throws Exception {
test(Artist.TYPE);
}
@Test
void customer() throws Exception {
test(Customer.TYPE);
}
@Test
void employee() throws Exception {
test(Employee.TYPE);
}
@Test
void genre() throws Exception {
test(Genre.TYPE);
}
@Test
void invoce() throws Exception {
test(Invoice.TYPE);
}
@Test
void invoiceLine() throws Exception {
test(InvoiceLine.TYPE);
}
@Test
void mediaType() throws Exception {
test(MediaType.TYPE);
}
@Test
void playlist() throws Exception {
test(Playlist.TYPE);
}
@Test
void playlistTrack() throws Exception {
test(PlaylistTrack.TYPE);
}
@Test
void track() throws Exception {
test(Track.TYPE);
}
@Test
void randomPlaylist() throws Exception {
EntityConnection connection = connection();
connection.startTransaction();
try {
Entity genre = connection.selectSingle(Genre.NAME.equalTo("Metal"));
int noOfTracks = 10;
String playlistName = "MetalPlaylistTest";
RandomPlaylistParameters parameters = new RandomPlaylistParameters(playlistName, noOfTracks, List.of(genre));
Entity playlist = connection.execute(Playlist.RANDOM_PLAYLIST, parameters);
assertEquals(playlistName, playlist.get(Playlist.NAME));
List<Entity> playlistTracks = connection.select(PlaylistTrack.PLAYLIST_FK.equalTo(playlist));
assertEquals(noOfTracks, playlistTracks.size());
playlistTracks.stream()
.map(playlistTrack -> playlistTrack.get(PlaylistTrack.TRACK_FK))
.forEach(track -> assertEquals(genre, track.get(Track.GENRE_FK)));
}
finally {
connection.rollbackTransaction();
}
}
private static final class ChinookEntityFactory extends DefaultEntityFactory {
private ChinookEntityFactory(EntityConnection connection) {
super(connection);
}
@Override
public void modify(Entity entity) throws DatabaseException {
super.modify(entity);
if (entity.entityType().equals(Album.TYPE)) {
entity.put(Album.TAGS, asList("tag_one", "tag_two", "tag_three"));
}
}
@Override
protected <T> T value(Attribute<T> attribute) throws DatabaseException {
if (attribute.equals(Album.TAGS)) {
return (T) asList("tag_one", "tag_two");
}
return super.value(attribute);
}
}
}Load test
package is.codion.framework.demos.chinook.client.loadtest;
import is.codion.common.user.User;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.InsertDeleteAlbum;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.InsertDeleteInvoice;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.LogoutLogin;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.RaisePrices;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.RandomPlaylist;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.UpdateTotals;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.ViewAlbum;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.ViewCustomerReport;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.ViewGenre;
import is.codion.framework.demos.chinook.client.loadtest.scenarios.ViewInvoice;
import is.codion.framework.demos.chinook.domain.api.Chinook;
import is.codion.framework.demos.chinook.model.ChinookAppModel;
import is.codion.framework.demos.chinook.ui.ChinookAppPanel;
import is.codion.tools.loadtest.LoadTest;
import is.codion.tools.loadtest.LoadTest.Scenario;
import is.codion.tools.loadtest.model.LoadTestModel;
import java.util.Collection;
import java.util.function.Function;
import static is.codion.tools.loadtest.LoadTest.Scenario.scenario;
import static is.codion.tools.loadtest.ui.LoadTestPanel.loadTestPanel;
import static java.util.Arrays.asList;
public final class ChinookLoadTest {
private static final User UNIT_TEST_USER =
User.parse(System.getProperty("codion.test.user", "scott:tiger"));
private static final Collection<Scenario<EntityConnectionProvider>> SCENARIOS = asList(
scenario(new ViewGenre(), 10),
scenario(new ViewCustomerReport(), 2),
scenario(new ViewInvoice(), 10),
scenario(new ViewAlbum(), 10),
scenario(new UpdateTotals(), 1),
scenario(new InsertDeleteAlbum(), 3),
scenario(new LogoutLogin(), 1),
scenario(new RaisePrices(), 1),
scenario(new RandomPlaylist(), 1),
scenario(new InsertDeleteInvoice(), 3));
private static final class ConnectionProviderFactory implements Function<User, EntityConnectionProvider> {
@Override
public EntityConnectionProvider apply(User user) {
EntityConnectionProvider connectionProvider = EntityConnectionProvider.builder()
.domainType(Chinook.DOMAIN)
.clientTypeId(ChinookAppPanel.class.getName())
.clientVersion(ChinookAppModel.VERSION)
.user(user)
.build();
connectionProvider.connection();
return connectionProvider;
}
}
public static void main(String[] args) {
LoadTest<EntityConnectionProvider> loadTest =
LoadTest.builder(new ConnectionProviderFactory(), EntityConnectionProvider::close)
.scenarios(SCENARIOS)
.user(UNIT_TEST_USER)
.build();
loadTestPanel(LoadTestModel.loadTestModel(loadTest)).run();
}
}Scenarios
package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import java.util.Random;
final class LoadTestUtil {
private static final int MAX_ARTIST_ID = 275;
private static final int MAX_CUSTOMER_ID = 59;
private static final int MAX_TRACK_ID = 3503;
static final Random RANDOM = new Random();
static long randomArtistId() {
return RANDOM.nextInt(MAX_ARTIST_ID) + 1;
}
static long randomCustomerId() {
return RANDOM.nextInt(MAX_CUSTOMER_ID) + 1;
}
static long randomTrackId() {
return RANDOM.nextInt(MAX_TRACK_ID) + 1;
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.MediaType;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomArtistId;
import static is.codion.framework.domain.entity.condition.Condition.all;
public final class InsertDeleteAlbum implements Performer<EntityConnectionProvider> {
private static final BigDecimal UNIT_PRICE = BigDecimal.valueOf(2);
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity artist = connection.selectSingle(Artist.ID.equalTo(randomArtistId()));
Entity album = connectionProvider.entities().builder(Album.TYPE)
.with(Album.ARTIST_FK, artist)
.with(Album.TITLE, "Title")
.build();
album = connection.insertSelect(album);
List<Entity> genres = connection.select(all(Genre.TYPE));
List<Entity> mediaTypes = connection.select(all(MediaType.TYPE));
Collection<Entity> tracks = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
Entity track = connectionProvider.entities().builder(Track.TYPE)
.with(Track.ALBUM_FK, album)
.with(Track.NAME, "Track " + i)
.with(Track.BYTES, RANDOM.nextInt(1_000_000))
.with(Track.COMPOSER, "Composer")
.with(Track.MILLISECONDS, RANDOM.nextInt(1_000_000))
.with(Track.UNITPRICE, UNIT_PRICE)
.with(Track.GENRE_FK, genres.get(RANDOM.nextInt(genres.size())))
.with(Track.MEDIATYPE_FK, mediaTypes.get(RANDOM.nextInt(mediaTypes.size())))
.with(Track.RATING, 5)
.build();
tracks.add(track);
}
tracks = connection.insertSelect(tracks);
Collection<Entity.Key> toDelete = new ArrayList<>(Entity.primaryKeys(tracks));
toDelete.add(album.primaryKey());
connection.delete(toDelete);
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
public final class LogoutLogin implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) {
try {
connectionProvider.close();
Thread.sleep(RANDOM.nextInt(1500));
connectionProvider.connection();
}
catch (InterruptedException ignored) {/*ignored*/}
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import static is.codion.framework.db.EntityConnection.transaction;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
import static java.util.Arrays.asList;
public final class RandomPlaylist implements Performer<EntityConnectionProvider> {
private static final String PLAYLIST_NAME = "Random playlist";
private static final Collection<String> GENRES =
asList("Alternative", "Rock", "Metal", "Heavy Metal", "Pop");
@Override
public void perform(EntityConnectionProvider connectionProvider) throws DatabaseException {
EntityConnection connection = connectionProvider.connection();
List<Entity> playlistGenres = connection.select(Genre.NAME.in(GENRES));
RandomPlaylistParameters parameters = new RandomPlaylistParameters(PLAYLIST_NAME + " " + UUID.randomUUID(),
RANDOM.nextInt(20) + 25, playlistGenres);
Entity playlist = transaction(connection, () -> connection.execute(Playlist.RANDOM_PLAYLIST, parameters));
Collection<Entity> playlistTracks = connection.select(PlaylistTrack.PLAYLIST_FK.equalTo(playlist));
Collection<Entity.Key> toDelete = Entity.primaryKeys(playlistTracks);
toDelete.add(playlist.primaryKey());
connection.delete(toDelete);
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track.RaisePriceParameters;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import static is.codion.framework.db.EntityConnection.Select.where;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomArtistId;
public final class RaisePrices implements Performer<EntityConnectionProvider> {
private static final BigDecimal PRICE_INCREASE = BigDecimal.valueOf(0.01);
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity artist = connection.selectSingle(Artist.ID.equalTo(randomArtistId()));
List<Entity> albums = connection.select(where(Album.ARTIST_FK.equalTo(artist))
.limit(1)
.build());
if (!albums.isEmpty()) {
List<Entity> tracks = connection.select(Track.ALBUM_FK.equalTo(albums.getFirst()));
Collection<Long> trackIds = Entity.values(Track.ID, tracks);
connection.execute(Track.RAISE_PRICE, new RaisePriceParameters(trackIds, PRICE_INCREASE));
}
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import static is.codion.framework.db.EntityConnection.transaction;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomCustomerId;
import static is.codion.framework.domain.entity.Entity.distinct;
public final class UpdateTotals implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity customer = connection.selectSingle(Customer.ID.equalTo(randomCustomerId()));
List<Long> invoiceIds = connection.select(Invoice.ID, Invoice.CUSTOMER_FK.equalTo(customer));
if (!invoiceIds.isEmpty()) {
Entity invoice = connection.selectSingle(Invoice.ID.equalTo(invoiceIds.get(RANDOM.nextInt(invoiceIds.size()))));
Collection<Entity> invoiceLines = connection.select(InvoiceLine.INVOICE_FK.equalTo(invoice));
invoiceLines.forEach(invoiceLine ->
invoiceLine.put(InvoiceLine.QUANTITY, RANDOM.nextInt(4) + 1));
updateInvoiceLines(invoiceLines.stream()
.filter(Entity::modified)
.collect(Collectors.toList()), connection);
}
}
private static void updateInvoiceLines(Collection<Entity> invoiceLines, EntityConnection connection) throws DatabaseException {
transaction(connection, () -> {
connection.update(invoiceLines);
connection.execute(Invoice.UPDATE_TOTALS, distinct(InvoiceLine.INVOICE_ID, invoiceLines));
});
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.List;
import static is.codion.framework.db.EntityConnection.Select.where;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomArtistId;
public final class ViewAlbum implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity artist = connection.selectSingle(Artist.ID.equalTo(randomArtistId()));
List<Entity> albums = connection.select(where(Album.ARTIST_FK.equalTo(artist))
.limit(1)
.build());
if (!albums.isEmpty()) {
connection.select(Chinook.Track.ALBUM_FK.equalTo(albums.getFirst()));
}
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomCustomerId;
public final class ViewCustomerReport implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity customer = connection.selectSingle(Customer.ID.equalTo(randomCustomerId()));
Collection<Long> customerIDs = List.of(customer.primaryKey().get());
Map<String, Object> reportParameters = new HashMap<>();
reportParameters.put("CUSTOMER_IDS", customerIDs);
connection.report(Customer.REPORT, reportParameters);
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.ArrayList;
import java.util.List;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
import static is.codion.framework.domain.entity.condition.Condition.all;
public final class ViewGenre implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
List<Entity> genres = connection.select(all(Genre.TYPE));
List<Entity> tracks = connection.select(Track.GENRE_FK.equalTo(genres.get(RANDOM.nextInt(genres.size()))));
if (!tracks.isEmpty()) {
connection.dependencies(new ArrayList<>(tracks.subList(0, Math.min(10, tracks.size()))));
}
}
}package is.codion.framework.demos.chinook.client.loadtest.scenarios;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.chinook.domain.api.Chinook.Customer;
import is.codion.framework.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.framework.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.framework.domain.entity.Entity;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.util.List;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.RANDOM;
import static is.codion.framework.demos.chinook.client.loadtest.scenarios.LoadTestUtil.randomCustomerId;
public final class ViewInvoice implements Performer<EntityConnectionProvider> {
@Override
public void perform(EntityConnectionProvider connectionProvider) throws Exception {
EntityConnection connection = connectionProvider.connection();
Entity customer = connection.selectSingle(Customer.ID.equalTo(randomCustomerId()));
List<Long> invoiceIds = connection.select(Invoice.ID, Invoice.CUSTOMER_FK.equalTo(customer));
if (!invoiceIds.isEmpty()) {
Entity invoice = connection.selectSingle(Invoice.ID.equalTo(invoiceIds.get(RANDOM.nextInt(invoiceIds.size()))));
connection.select(InvoiceLine.INVOICE_FK.equalTo(invoice));
}
}
}Service
package is.codion.framework.demos.chinook.service;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.property.PropertyValue;
import is.codion.framework.demos.chinook.service.connection.ConnectionSupplier;
import is.codion.framework.demos.chinook.service.handler.AlbumHandler;
import is.codion.framework.demos.chinook.service.handler.ArtistHandler;
import is.codion.framework.demos.chinook.service.handler.GenreHandler;
import is.codion.framework.demos.chinook.service.handler.MediaTypeHandler;
import is.codion.framework.demos.chinook.service.handler.TrackHandler;
import io.javalin.Javalin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.ExecutorService;
import static is.codion.common.Configuration.integerValue;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
final class ChinookService {
private static final Logger LOG = LoggerFactory.getLogger(ChinookService.class);
static final PropertyValue<Integer> PORT =
integerValue("chinook.service.port", 8089);
private final Javalin javalin = Javalin.create();
private final ConnectionSupplier connectionSupplier = new ConnectionSupplier();
private final ArtistHandler artists = new ArtistHandler(connectionSupplier);
private final AlbumHandler albums = new AlbumHandler(connectionSupplier);
private final TrackHandler tracks = new TrackHandler(connectionSupplier);
private final MediaTypeHandler mediaType = new MediaTypeHandler(connectionSupplier);
private final GenreHandler genre = new GenreHandler(connectionSupplier);
ChinookService() throws DatabaseException {
javalin.get("/artists", artists::artists);
javalin.get("/artists/id/{id}", artists::byId);
javalin.get("/artists/name/{name}", artists::byName);
javalin.post("/artists", artists::insert);
javalin.get("/albums", albums::albums);
javalin.get("/albums/id/{id}", albums::byId);
javalin.get("/albums/title/{title}", albums::byTitle);
javalin.get("/albums/artist/name/{name}", albums::byArtistName);
javalin.post("/albums", albums::insert);
javalin.get("/tracks", tracks::tracks);
javalin.get("/tracks/id/{id}", tracks::byId);
javalin.get("/tracks/name/{name}", tracks::byName);
javalin.get("/tracks/artist/name/{name}", tracks::byArtistName);
javalin.post("/tracks", tracks::insert);
javalin.post("/mediatypes", mediaType::insert);
javalin.post("/genres", genre::insert);
}
void start() {
LOG.info("Chinook service starting on port: {}", PORT.get());
try {
javalin.start(PORT.get());
}
catch (RuntimeException e) {
LOG.error(e.getMessage(), e);
throw e;
}
}
void stop() {
javalin.stop();
}
public static void main(String[] args) throws Exception {
try (ExecutorService service = newSingleThreadExecutor()) {
service.submit(new ChinookService()::start).get();
}
catch (Exception e) {
LOG.error(e.getMessage(), e);
}
}
}Connection
package is.codion.framework.demos.chinook.service.connection;
import is.codion.common.db.database.Database;
import is.codion.common.db.exception.DatabaseException;
import is.codion.common.db.pool.ConnectionPoolFactory;
import is.codion.common.db.pool.ConnectionPoolStatistics;
import is.codion.common.db.pool.ConnectionPoolWrapper;
import is.codion.common.scheduler.TaskScheduler;
import is.codion.common.user.User;
import is.codion.framework.db.local.LocalEntityConnection;
import is.codion.framework.demos.chinook.domain.api.Chinook;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.MediaType;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.domain.Domain;
import is.codion.framework.domain.DomainModel;
import is.codion.framework.domain.entity.Entities;
import org.slf4j.Logger;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import static is.codion.framework.db.local.LocalEntityConnection.localEntityConnection;
import static java.lang.System.currentTimeMillis;
import static org.slf4j.LoggerFactory.getLogger;
public final class ConnectionSupplier implements Supplier<LocalEntityConnection> {
private static final Logger LOG = getLogger(ConnectionSupplier.class);
private static final User USER = User.parse("scott:tiger");
private static final int STATISTICS_PRINT_RATE = 5;
private final Domain domain = new ServiceDomain();
// Relies on the codion-dbms-h2 module and the h2 driver being
// on the classpath and the 'codion.db.url' system property
private final Database database = Database.instance();
private final ConnectionPoolWrapper connectionPool =
// Relies on codion-plugin-hikari-pool being on the classpath
database.createConnectionPool(ConnectionPoolFactory.instance(), USER);
public ConnectionSupplier() throws DatabaseException {
connectionPool.setCollectCheckOutTimes(true);
LOG.info("Database: {}", database.url());
LOG.info("Connection pool: {}", connectionPool.user());
LOG.info("Domain: {}", domain.type().name());
TaskScheduler.builder(this::printStatistics)
.interval(STATISTICS_PRINT_RATE, TimeUnit.SECONDS)
.start();
}
@Override
public LocalEntityConnection get() {
try {
return localEntityConnection(database, domain, connectionPool.connection(USER));
}
catch (DatabaseException e) {
LOG.error(e.getMessage(), e);
throw new RuntimeException(e.getMessage());
}
}
public Entities entities() {
return domain.entities();
}
private void printStatistics() {
ConnectionPoolStatistics poolStatistics =
// fetch statistics collected since last time we fetched
connectionPool.statistics(currentTimeMillis() - STATISTICS_PRINT_RATE * 1_000);
System.out.println("#### Connection Pool ############");
System.out.println("# Requests per second: " + poolStatistics.requestsPerSecond());
System.out.println("# Average check out time: " + poolStatistics.averageGetTime() + " ms");
System.out.println("# Size: " + poolStatistics.size() + ", in use: " + poolStatistics.inUse());
System.out.println("#### Database ###################");
Database.Statistics databaseStatistics = database.statistics();
System.out.println("# Queries per second: " + databaseStatistics.queriesPerSecond());
System.out.println("#################################");
}
private static final class ServiceDomain extends DomainModel {
private ServiceDomain() {
super(Chinook.DOMAIN);
// Relies on the the Chinook domain model
// being registered as a service
Entities entities = Domain.domains().getFirst().entities();
// Only add the entities required for this service
add(entities.definition(Genre.TYPE));
add(entities.definition(MediaType.TYPE));
add(entities.definition(Artist.TYPE));
add(entities.definition(Album.TYPE));
add(entities.definition(Track.TYPE));
}
}
}Handlers
package is.codion.framework.demos.chinook.service.handler;
import is.codion.framework.db.local.LocalEntityConnection;
import is.codion.framework.demos.chinook.service.connection.ConnectionSupplier;
import is.codion.framework.domain.entity.Entities;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.javalin.http.Context;
import org.eclipse.jetty.http.HttpStatus;
import org.slf4j.Logger;
import java.util.function.Supplier;
import static org.slf4j.LoggerFactory.getLogger;
public abstract class AbstractHandler {
private static final Logger LOG = getLogger(AbstractHandler.class);
private static final ObjectMapper MAPPER = new ObjectMapper();
private final Supplier<LocalEntityConnection> connection;
private final Entities entities;
protected AbstractHandler(ConnectionSupplier connection) {
this.connection = connection;
this.entities = connection.entities();
}
protected final LocalEntityConnection connection() {
return connection.get();
}
protected final ObjectMapper mapper() {
return MAPPER;
}
protected final Entities entities() {
return entities;
}
protected static void handleException(Context context, Exception exception) {
LOG.error(exception.getMessage(), exception);
context.status(HttpStatus.INTERNAL_SERVER_ERROR_500);
}
}package is.codion.framework.demos.chinook.service.handler;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.service.connection.ConnectionSupplier;
import is.codion.framework.domain.entity.Entity;
import io.javalin.http.Context;
import org.eclipse.jetty.http.HttpStatus;
import static io.javalin.http.HttpStatus.OK;
import static is.codion.framework.db.EntityConnection.Select.all;
import static java.lang.Long.parseLong;
import static java.util.stream.StreamSupport.stream;
public final class ArtistHandler extends AbstractHandler {
public ArtistHandler(ConnectionSupplier connection) {
super(connection);
}
public void artists(Context context) {
try (var connection = connection();
var iterator = connection.iterator(all(Artist.TYPE).build())) {
context.status(HttpStatus.OK_200)
.writeJsonStream(stream(iterator.spliterator(), false)
.map(Artist::dto));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byName(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(connection.select(
Artist.NAME.equalToIgnoreCase(context.pathParam("name")))
.stream()
.map(Artist::dto)
.toList()));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byId(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(
Artist.dto(connection.selectSingle(
Artist.ID.equalTo(parseLong(context.pathParam("id")))))));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void insert(Context context) {
try (var connection = connection()) {
Artist.Dto artistDto = context.bodyStreamAsClass(Artist.Dto.class);
Entity artist = connection.insertSelect(artistDto.entity(entities()));
context.status(OK)
.result(mapper().writeValueAsString(Artist.dto(artist)));
}
catch (Exception e) {
handleException(context, e);
}
}
}package is.codion.framework.demos.chinook.service.handler;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.service.connection.ConnectionSupplier;
import is.codion.framework.domain.entity.Entity;
import io.javalin.http.Context;
import org.eclipse.jetty.http.HttpStatus;
import static io.javalin.http.HttpStatus.OK;
import static is.codion.framework.db.EntityConnection.Select.all;
import static java.lang.Long.parseLong;
import static java.util.stream.StreamSupport.stream;
public final class AlbumHandler extends AbstractHandler {
public AlbumHandler(ConnectionSupplier connection) {
super(connection);
}
public void albums(Context context) {
try (var connection = connection();
var iterator = connection.iterator(all(Album.TYPE).build())) {
context.status(HttpStatus.OK_200)
.writeJsonStream(stream(iterator.spliterator(), false)
.map(Album::dto));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byTitle(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(connection.select(
Album.TITLE.equalToIgnoreCase(context.pathParam("title")))
.stream()
.map(Album::dto)
.toList()));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byArtistName(Context context) {
try (var connection = connection()) {
var artistIds = connection.select(Artist.ID,
Artist.NAME.equalToIgnoreCase(context.pathParam("name")));
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(
connection.select(Album.ARTIST_ID.in(artistIds))
.stream()
.map(Album::dto)
.toList()));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byId(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(
Album.dto(connection.selectSingle(
Album.ID.equalTo(parseLong(context.pathParam("id")))))));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void insert(Context context) {
try (var connection = connection()) {
Album.Dto albumDto = context.bodyStreamAsClass(Album.Dto.class);
Entity album = connection.insertSelect(albumDto.entity(entities()));
context.status(OK)
.result(mapper().writeValueAsString(Album.dto(album)));
}
catch (Exception e) {
handleException(context, e);
}
}
}package is.codion.framework.demos.chinook.service.handler;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.demos.chinook.service.connection.ConnectionSupplier;
import is.codion.framework.domain.entity.Entity;
import io.javalin.http.Context;
import org.eclipse.jetty.http.HttpStatus;
import static io.javalin.http.HttpStatus.OK;
import static is.codion.framework.db.EntityConnection.Select.all;
import static java.lang.Long.parseLong;
import static java.util.stream.StreamSupport.stream;
public final class TrackHandler extends AbstractHandler {
public TrackHandler(ConnectionSupplier connection) {
super(connection);
}
public void tracks(Context context) {
try (var connection = connection();
var iterator = connection.iterator(all(Track.TYPE).build())) {
context.status(HttpStatus.OK_200)
.writeJsonStream(stream(iterator.spliterator(), false)
.map(Track::dto));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byName(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(connection.select(
Track.NAME.equalToIgnoreCase(context.pathParam("name")))
.stream()
.map(Track::dto)
.toList()));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byArtistName(Context context) {
try (var connection = connection()) {
var artistIds = connection.select(Artist.ID,
Artist.NAME.equalToIgnoreCase(context.pathParam("name")));
var albumIds = connection.select(Album.ID,
Album.ARTIST_ID.in(artistIds));
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(
connection.select(Track.ALBUM_ID.in(albumIds))
.stream()
.map(Track::dto)
.toList()));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void byId(Context context) {
try (var connection = connection()) {
context.status(HttpStatus.OK_200)
.result(mapper().writeValueAsString(
Track.dto(connection.selectSingle(
Track.ID.equalTo(parseLong(context.pathParam("id")))))));
}
catch (Exception exception) {
handleException(context, exception);
}
}
public void insert(Context context) {
try (var connection = connection()) {
Track.Dto trackDto = context.bodyStreamAsClass(Track.Dto.class);
Entity track = connection.insertSelect(trackDto.entity(entities()));
context.status(OK)
.result(mapper().writeValueAsString(Track.dto(track)));
}
catch (Exception e) {
handleException(context, e);
}
}
}Unit test
package is.codion.framework.demos.chinook.service;
import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.demos.chinook.domain.api.Chinook.Album;
import is.codion.framework.demos.chinook.domain.api.Chinook.Artist;
import is.codion.framework.demos.chinook.domain.api.Chinook.Genre;
import is.codion.framework.demos.chinook.domain.api.Chinook.MediaType;
import is.codion.framework.demos.chinook.domain.api.Chinook.Track;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.javalin.http.HttpStatus;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.ExecutorService;
import static io.javalin.http.HttpStatus.INTERNAL_SERVER_ERROR;
import static io.javalin.http.HttpStatus.OK;
import static is.codion.framework.demos.chinook.service.ChinookService.PORT;
import static java.net.URLEncoder.encode;
import static java.net.http.HttpClient.newHttpClient;
import static java.net.http.HttpRequest.BodyPublishers.ofString;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class ChinookServiceTest {
private static final ExecutorService EXECUTOR = newSingleThreadExecutor();
private static final String BASE_URL = "http://localhost:" + PORT.get();
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private static ChinookService SERVICE;
@BeforeAll
static void setUp() throws DatabaseException {
SERVICE = new ChinookService();
EXECUTOR.submit(SERVICE::start);
}
@AfterAll
static void tearDown() {
SERVICE.stop();
EXECUTOR.shutdownNow();
}
@Test
public void get() throws Exception {
try (HttpClient client = newHttpClient()) {
assertGet("/artists/id/42", OK, client);
assertGet("/artists/id/-42", INTERNAL_SERVER_ERROR, client);
assertGet("/artists", OK, client);
assertGet("/artists/name/metallica", OK, client);
assertGet("/albums/id/42", OK, client);
assertGet("/albums/id/-42", INTERNAL_SERVER_ERROR, client);
assertGet("/albums", OK, client);
assertGet("/albums/title/" + encode("master of puppets"), OK, client);
assertGet("/albums/artist/name/metallica", OK, client);
assertGet("/tracks/id/42", OK, client);
assertGet("/tracks/id/-42", INTERNAL_SERVER_ERROR, client);
assertGet("/tracks", OK, client);
assertGet("/tracks/name/orion", OK, client);
assertGet("/tracks/artist/name/metallica", OK, client);
}
}
@Test
public void post() throws Exception {
try (HttpClient client = newHttpClient()) {
String payload = OBJECT_MAPPER.writeValueAsString(new MediaType.Dto(null, "New mediatype"));
MediaType.Dto mediaType = OBJECT_MAPPER.readerFor(MediaType.Dto.class)
.readValue(assertPost("/mediatypes", OK, client, payload));
assertEquals("New mediatype", mediaType.name());
payload = OBJECT_MAPPER.writeValueAsString(new Genre.Dto(null, "New genre"));
Genre.Dto genre = OBJECT_MAPPER.readerFor(Genre.Dto.class)
.readValue(assertPost("/genres", OK, client, payload));
assertEquals("New genre", genre.name());
payload = OBJECT_MAPPER.writeValueAsString(new Artist.Dto(null, "New artist"));
Artist.Dto artist = OBJECT_MAPPER.readerFor(Artist.Dto.class)
.readValue(assertPost("/artists", OK, client, payload));
assertEquals("New artist", artist.name());
payload = OBJECT_MAPPER.writeValueAsString(new Album.Dto(null, "New album", artist));
Album.Dto album = OBJECT_MAPPER.readerFor(Album.Dto.class)
.readValue(assertPost("/albums", OK, client, payload));
assertEquals("New album", album.title());
payload = OBJECT_MAPPER.writeValueAsString(new Track.Dto(null, "New track", album, genre,
mediaType, 10_000_000, 7, BigDecimal.ONE));
Track.Dto track = OBJECT_MAPPER.readerFor(Track.Dto.class)
.readValue(assertPost("/tracks", OK, client, payload));
assertEquals("New track", track.name());
assertEquals(album, track.album());
assertEquals(genre, track.genre());
assertEquals(mediaType, track.mediaType());
assertEquals(10_000_000, track.milliseconds());
assertEquals(7, track.rating());
assertEquals(BigDecimal.ONE, track.unitPrice());
}
}
private void assertGet(String url, HttpStatus status, HttpClient client) throws Exception {
assertEquals(status.getCode(),
client.send(HttpRequest.newBuilder()
.uri(URI.create(BASE_URL + url))
.GET()
.build(), ofString())
.statusCode());
}
private String assertPost(String url, HttpStatus status, HttpClient client,
String payload) throws Exception {
HttpResponse<String> response = client.send(HttpRequest.newBuilder()
.uri(URI.create(BASE_URL + url))
.POST(ofString(payload))
.build(), ofString());
assertEquals(status.getCode(), response.statusCode());
return response.body();
}
}Service load test
package is.codion.framework.demos.chinook.service.loadtest;
import is.codion.common.property.PropertyValue;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.AlbumById;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.Albums;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.ArtistById;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.Artists;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.NewArtist;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.TrackById;
import is.codion.framework.demos.chinook.service.loadtest.scenarios.Tracks;
import is.codion.tools.loadtest.LoadTest;
import is.codion.tools.loadtest.LoadTest.Scenario;
import is.codion.tools.loadtest.model.LoadTestModel;
import java.net.http.HttpClient;
import java.util.List;
import static is.codion.common.Configuration.integerValue;
import static is.codion.common.user.User.user;
import static is.codion.tools.loadtest.LoadTest.Scenario.scenario;
import static is.codion.tools.loadtest.ui.LoadTestPanel.loadTestPanel;
import static java.net.http.HttpClient.newHttpClient;
public final class ChinookServiceLoadTest {
private static final PropertyValue<Integer> PORT =
integerValue("chinook.service.port", 8089);
private static final String BASE_URL = "http://localhost:" + PORT.get();
private static final List<Scenario<HttpClient>> SCENARIOS = List.of(
scenario(new Artists(BASE_URL)),
scenario(new ArtistById(BASE_URL)),
scenario(new Albums(BASE_URL)),
scenario(new AlbumById(BASE_URL)),
scenario(new Tracks(BASE_URL)),
scenario(new TrackById(BASE_URL)),
scenario(new NewArtist(BASE_URL))
);
public static void main(String[] args) {
LoadTest<HttpClient> loadTest =
LoadTest.builder(user -> newHttpClient(), HttpClient::close)
.scenarios(SCENARIOS)
.user(user("n/a"))
.build();
loadTestPanel(LoadTestModel.loadTestModel(loadTest)).run();
}
}Scenarios
package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.util.Random;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class ArtistById implements Performer<HttpClient> {
private static final Random RANDOM = new Random();
private final String baseUrl;
public ArtistById(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/artists/id/" + randomArtistId()))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return ArtistById.class.getSimpleName();
}
private static int randomArtistId() {
return RANDOM.nextInt(275) + 1;
}
}package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class Artists implements Performer<HttpClient> {
private final String baseUrl;
public Artists(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/artists"))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return Artists.class.getSimpleName();
}
}package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.util.Random;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class AlbumById implements Performer<HttpClient> {
private static final Random RANDOM = new Random();
private final String baseUrl;
public AlbumById(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/albums/id/" + randomAlbumId()))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return AlbumById.class.getSimpleName();
}
private static int randomAlbumId() {
return RANDOM.nextInt(347) + 1;
}
}package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class Albums implements Performer<HttpClient> {
private final String baseUrl;
public Albums(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/albums"))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return Albums.class.getSimpleName();
}
}package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.util.Random;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class TrackById implements Performer<HttpClient> {
private static final Random RANDOM = new Random();
private final String baseUrl;
public TrackById(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/tracks/id/" + randomTrackId()))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return TrackById.class.getSimpleName();
}
private static int randomTrackId() {
return RANDOM.nextInt(3503) + 1;
}
}package is.codion.framework.demos.chinook.service.loadtest.scenarios;
import is.codion.tools.loadtest.LoadTest.Scenario.Performer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import static java.net.http.HttpResponse.BodyHandlers.ofString;
public final class Tracks implements Performer<HttpClient> {
private final String baseUrl;
public Tracks(String baseUrl) {
this.baseUrl = baseUrl;
}
@Override
public void perform(HttpClient client) throws Exception {
if (client.send(HttpRequest.newBuilder()
.uri(URI.create(baseUrl + "/tracks"))
.build(), ofString()).statusCode() != 200) {
throw new Exception(toString());
}
}
@Override
public String toString() {
return Tracks.class.getSimpleName();
}
}Module Info
Domain
API
/**
* Domain API.
*/
module is.codion.framework.demos.chinook.domain.api {
requires is.codion.common.db;
requires is.codion.framework.db.core;
requires transitive is.codion.plugin.jasperreports;
requires org.apache.commons.logging;
exports is.codion.framework.demos.chinook.domain.api;
//for accessing i18n resources
opens is.codion.framework.demos.chinook.domain.api;
}Implementation
/**
* Domain implementation.
*/
module is.codion.framework.demos.chinook.domain {
requires is.codion.common.db;
requires is.codion.common.rmi;
requires is.codion.framework.i18n;
requires is.codion.framework.db.core;
requires is.codion.framework.db.local;
requires transitive is.codion.framework.demos.chinook.domain.api;
opens is.codion.framework.demos.chinook.domain;//report resource
exports is.codion.framework.demos.chinook.domain;
exports is.codion.framework.demos.chinook.server;
provides is.codion.framework.domain.Domain
with is.codion.framework.demos.chinook.domain.ChinookImpl;
provides is.codion.common.rmi.server.Authenticator
with is.codion.framework.demos.chinook.server.ChinookAuthenticator;
provides is.codion.common.resource.Resources
with is.codion.framework.demos.chinook.domain.ChinookResources;
}Client
/**
* Client.
*/
module is.codion.framework.demos.chinook.client {
requires is.codion.swing.common.ui;
requires is.codion.swing.framework.ui;
requires is.codion.plugin.imagepanel;
requires is.codion.framework.demos.chinook.domain.api;
requires com.formdev.flatlaf.intellijthemes;
requires org.kordamp.ikonli.foundation;
requires net.sf.jasperreports.core;
requires net.sf.jasperreports.pdf;
requires org.apache.commons.logging;
requires com.github.librepdf.openpdf;
exports is.codion.framework.demos.chinook.ui;
exports is.codion.framework.demos.chinook.model;
}Load Test
/**
* Load test.
*/
module is.codion.framework.demos.chinook.client.loadtest {
requires is.codion.common.model;
requires is.codion.tools.loadtest.ui;
requires is.codion.framework.db.core;
requires is.codion.framework.demos.chinook.domain.api;
requires is.codion.framework.demos.chinook.client;
}