Chinook Tutorial

  interface Customer {
    EntityType TYPE = DOMAIN.entityType("chinook.customer", Customer.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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("supportrep_id");

    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;

    private static final String LANGUAGE = Locale.getDefault().getLanguage();

    @Override
    public String apply(Entity customer) {
      return switch (LANGUAGE) {
        case "en" -> new StringBuilder()
                .append(customer.get(Customer.LASTNAME))
                .append(", ")
                .append(customer.get(Customer.FIRSTNAME))
                .toString();
        case "is" -> new StringBuilder()
                .append(customer.get(Customer.FIRSTNAME))
                .append(" ")
                .append(customer.get(Customer.LASTNAME))
                .toString();
        default -> throw new IllegalArgumentException("Unsupported language: " + LANGUAGE);
      };
    }
  }

  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))
            .keyGenerator(identity())
            .validator(new EmailValidator(Customer.EMAIL))
            .orderBy(ascending(Customer.LASTNAME, Customer.FIRSTNAME))
            .stringFactory(new CustomerStringFactory())
            .build();
  }

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Invoice;
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()));

    detailPanels().add(new InvoicePanel(customerModel.detailModels().get(Invoice.TYPE)));
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Customer;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.key.KeyEvents;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;

import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.event.ActionEvent;

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.dialog.Dialogs.listSelectionDialog;
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_SPACE;

public final class CustomerEditPanel extends EntityEditPanel {

  public CustomerEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    focus().initial().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)
            // CTRL-SPACE displays a dialog for selecting
            // a State from existing column values
            .keyEvent(KeyEvents.builder(VK_SPACE)
                    .modifiers(CTRL_DOWN_MASK)
                    .action(Control.action(this::selectState)));
    createTextField(Customer.COUNTRY)
            .columns(8);
    createTextField(Customer.PHONE)
            .columns(12);
    createTextField(Customer.FAX)
            .columns(12);
    createComboBox(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 void selectState(ActionEvent event) {
    JTextField stateField = (JTextField) event.getSource();
    listSelectionDialog(editModel().connection().select(Customer.STATE))
            .owner(stateField)
            .selectSingle()
            .ifPresent(stateField::setText);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.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
            // Otherwise the table refresh button is only
            // visible when the condition panel is visible
            .refreshButtonVisible(RefreshButtonVisible.ALWAYS));
  }

  @Override
  protected void setupControls() {
    // Assign a custom report action to the standard PRINT control,
    // which is then made available in the popup menu and on the toolbar
    control(PRINT).set(Control.builder()
            .command(this::viewCustomerReport)
            .caption(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() {
    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();
  }
}

  interface Invoice {
    EntityType TYPE = DOMAIN.entityType("chinook.invoice", Invoice.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<Long> CUSTOMER_ID = TYPE.longColumn("customer_id");
    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;
  }

  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 invoice_id = invoice.id""")
                            .maximumFractionDigits(2))
            .keyGenerator(identity())
            .orderBy(OrderBy.builder()
                    .ascending(Invoice.CUSTOMER_ID)
                    .descending(Invoice.DATE)
                    .build())
            .stringFactory(Invoice.ID)
            .build();
  }

  private static final class UpdateTotalsFunction implements DatabaseFunction<EntityConnection, Collection<Long>, Collection<Entity>> {

    @Override
    public Collection<Entity> execute(EntityConnection connection,
                                      Collection<Long> invoiceIds) {
      Collection<Entity> invoices =
              connection.select(where(Invoice.ID.in(invoiceIds))
                      .forUpdate()
                      .build());

      return connection.updateSelect(invoices.stream()
              .map(UpdateTotalsFunction::updateTotal)
              .filter(Entity::modified)
              .toList());
    }

    private static Entity updateTotal(Entity invoice) {
      invoice.set(Invoice.TOTAL, invoice.optional(Invoice.CALCULATED_TOTAL).orElse(BigDecimal.ZERO));

      return invoice;
    }
  }

package is.codion.demos.chinook.model;

import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityModel;

import java.util.Collection;

import static javax.swing.SwingUtilities.invokeLater;

public final class InvoiceModel extends SwingEntityModel {

  public InvoiceModel(EntityConnectionProvider connectionProvider) {
    super(new InvoiceEditModel(connectionProvider));

    InvoiceLineEditModel invoiceLineEditModel = new InvoiceLineEditModel(connectionProvider);

    SwingEntityModel invoiceLineModel = new SwingEntityModel(invoiceLineEditModel);
    detailModels().add(link(invoiceLineModel)
            // Prevents accidentally adding a new invoice line to the previously selected invoice,
            // since the selected foreign key value persists when the master selection is cleared by default.
            .clearValueOnEmptySelection(true)
            // Usually the UI is responsible for activating the detail model link for the currently
            // active (or visible) detail panel, but since the InvoiceLine panel is embedded in the
            // InvoiceEditPanel, we simply activate the link here.
            .active(true)
            .build());

    // We listen for when invoice totals are updated by the edit model,
    // and replace the invoices in the table model with the updated ones.
    // Note the use of invokeLater() since the event is triggered during
    // update, which happens in a background thread, so we have to update
    // the table data on the Event Dispatch Thread.
    invoiceLineEditModel.totalsUpdated().addConsumer(this::onTotalsUpdated);
  }

  private void onTotalsUpdated(Collection<Entity> updatedInvoices) {
    invokeLater(() -> tableModel().replace(updatedInvoices));
  }
}

package is.codion.demos.chinook.model;

import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.swing.framework.model.SwingEntityEditModel;

import java.util.Collection;

import static is.codion.demos.chinook.domain.api.Chinook.Customer;
import static is.codion.demos.chinook.domain.api.Chinook.Invoice;

public final class InvoiceEditModel extends SwingEntityEditModel {

  public InvoiceEditModel(EntityConnectionProvider connectionProvider) {
    super(Invoice.TYPE, connectionProvider);
    // By default, foreign key values persist when the model
    // is cleared, here we disable that for CUSTOMER_FK
    editor().value(Invoice.CUSTOMER_FK).persist().set(false);
    // We populate the invoice address fields with
    // the customer address when the customer is edited
    editor().value(Invoice.CUSTOMER_FK).edited().addConsumer(this::setAddress);
  }

  // Override to update the billing address when the invoice customer is changed.
  // This method is called when editing happens outside of the edit model,
  // such as in a table, via an editable table cell or multi item editing
  @Override
  public <T> void applyEdit(Collection<Entity> invoices, Attribute<T> attribute, T value) {
    super.applyEdit(invoices, attribute, value);
    if (attribute.equals(Invoice.CUSTOMER_FK)) {
      Entity customer = (Entity) value;
      invoices.forEach(invoice -> {
        // Set the billing address
        invoice.set(Invoice.BILLINGADDRESS, customer.get(Customer.ADDRESS));
        invoice.set(Invoice.BILLINGCITY, customer.get(Customer.CITY));
        invoice.set(Invoice.BILLINGPOSTALCODE, customer.get(Customer.POSTALCODE));
        invoice.set(Invoice.BILLINGSTATE, customer.get(Customer.STATE));
        invoice.set(Invoice.BILLINGCOUNTRY, customer.get(Customer.COUNTRY));
      });
    }
  }

  private void setAddress(Entity customer) {
    editor().value(Invoice.BILLINGADDRESS).set(customer == null ? null : customer.get(Customer.ADDRESS));
    editor().value(Invoice.BILLINGCITY).set(customer == null ? null : customer.get(Customer.CITY));
    editor().value(Invoice.BILLINGPOSTALCODE).set(customer == null ? null : customer.get(Customer.POSTALCODE));
    editor().value(Invoice.BILLINGSTATE).set(customer == null ? null : customer.get(Customer.STATE));
    editor().value(Invoice.BILLINGCOUNTRY).set(customer == null ? null : customer.get(Customer.COUNTRY));
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;

public final class InvoicePanel extends EntityPanel {

  public InvoicePanel(SwingEntityModel invoiceModel) {
    super(invoiceModel,
            new InvoiceEditPanel(invoiceModel.editModel(),
                    invoiceModel.detailModels().get(InvoiceLine.TYPE)),
            new InvoiceTablePanel(invoiceModel.tableModel()),
            // The InvoiceLine panel is embedded in InvoiceEditPanel,
            // so this panel doesn't need a detail panel layout.
            config -> config.detailLayout(DetailLayout.NONE));
    InvoiceEditPanel editPanel = (InvoiceEditPanel) editPanel();
    // We still add the InvoiceLine panel as a detail panel for keyboard navigation
    detailPanels().add(editPanel.invoiceLinePanel());
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Customer;
import is.codion.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.SwingEntityModel;
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.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;

public final class InvoiceEditPanel extends EntityEditPanel {

  private final EntityPanel invoiceLinePanel;

  public InvoiceEditPanel(SwingEntityEditModel editModel, SwingEntityModel invoiceLineModel) {
    super(editModel, config ->
            // We want this edit panel to keep displaying a newly inserted invoice,
            // since we will continue to work with it, by adding invoice lines for example
            config.clearAfterInsert(false));
    this.invoiceLinePanel = createInvoiceLinePanel(invoiceLineModel);
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(Invoice.CUSTOMER_FK);

    createSearchField(Invoice.CUSTOMER_FK)
            .columns(14)
            // We add a custom selector factory, creating a selector which
            // displays a table instead of a list when selecting a customer
            .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);
  }

  EntityPanel invoiceLinePanel() {
    return invoiceLinePanel;
  }

  private static EntityPanel createInvoiceLinePanel(SwingEntityModel invoiceLineModel) {
    // Here we construct the InvoiceLine panel, which will
    // be embedded in this edit panel, see initializeUI().
    InvoiceLineTablePanel invoiceLineTablePanel =
            new InvoiceLineTablePanel(invoiceLineModel.tableModel());
    InvoiceLineEditPanel invoiceLineEditPanel =
            new InvoiceLineEditPanel(invoiceLineModel.editModel(),
                    invoiceLineTablePanel.table().searchField());

    return new EntityPanel(invoiceLineModel,
            invoiceLineEditPanel, invoiceLineTablePanel, config ->
            // We don't include controls so that no buttons appear on this panel
            config.includeControls(false));
  }

  private static final class CustomerSelectorFactory implements Function<EntitySearchField, Selector> {

    @Override
    public Selector apply(EntitySearchField searchField) {
      // We use the TableSelector, provided by EntitySearchField,
      // configuring the the visible table columns, the sorting and size
      TableSelector selector = EntitySearchField.tableSelector(searchField);
      selector.table().columnModel().visible().set(Customer.LASTNAME, Customer.FIRSTNAME, Customer.EMAIL);
      selector.table().model().sort().ascending(Customer.LASTNAME, Customer.FIRSTNAME);
      selector.preferredSize(new Dimension(500, 300));

      return selector;
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.model.condition.TableConditionModel;
import is.codion.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
            // The TOTAL column is updated automatically when invoice lines are updated,
            // see InvoiceLineEditModel, so we don't want it to be editable via the popup menu.
            .editable(attributes -> attributes.remove(Invoice.TOTAL))
            // The factory providing our custom condition panel.
            .conditionPanelFactory(new InvoiceConditionPanelFactory(tableModel))
            // Start with the SIMPLE condition panel view.
            .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);
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.Operator;
import is.codion.common.item.Item;
import is.codion.common.model.condition.ConditionModel;
import is.codion.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.EntityTableConditionModel;
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.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().condition().conditionModel(),
            attribute -> columnModel.column(attribute).getHeaderValue().toString());
    setLayout(new BorderLayout());
    tableModel.queryModel().condition().persist().add(Invoice.DATE);
    this.simpleConditionPanel = new SimpleConditionPanel(tableModel);
    this.advancedConditionPanel = filterTableConditionPanel(tableModel.queryModel().condition().conditionModel(),
            conditionPanels, columnModel, onPanelInitialized);
    view().link(advancedConditionPanel.view());
  }

  @Override
  public Map<Attribute<?>, ConditionPanel<?>> panels() {
    Map<Attribute<?>, ConditionPanel<?>> conditionPanels =
            new HashMap<>(advancedConditionPanel.panels());
    conditionPanels.putAll(simpleConditionPanel.panels());

    return conditionPanels;
  }

  @Override
  public Map<Attribute<?>, ConditionPanel<?>> selectable() {
    return view().isEqualTo(ADVANCED) ? advancedConditionPanel.selectable() : simpleConditionPanel.panels();
  }

  @Override
  public ConditionPanel<?> panel(Attribute<?> attribute) {
    if (view().isNotEqualTo(ADVANCED)) {
      return simpleConditionPanel.panel(attribute);
    }

    return advancedConditionPanel.panel(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.panel(Invoice.CUSTOMER_FK).requestInputFocus();
        }
        else if (simpleConditionPanel.dateConditionPanel.isFocused()) {
          advancedConditionPanel.panel(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(SwingEntityTableModel tableModel) {
      super(new BorderLayout());
      setBorder(createEmptyBorder(5, 5, 5, 5));
      EntityTableConditionModel entityConditionModel = tableModel.queryModel().condition();
      ForeignKeyConditionModel customerConditionModel = entityConditionModel.get(Invoice.CUSTOMER_FK);
      customerConditionPanel = new CustomerConditionPanel(customerConditionModel, tableModel.entityDefinition());
      dateConditionPanel = new DateConditionPanel(entityConditionModel.get(Invoice.DATE));
      dateConditionPanel.yearValue.addListener(tableModel.items()::refresh);
      dateConditionPanel.monthValue.addListener(tableModel.items()::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.model().operator().set(Operator.IN);
      dateConditionPanel.model().operator().set(Operator.BETWEEN);
      customerConditionPanel.requestInputFocus();
    }

    private static final class CustomerConditionPanel extends ConditionPanel<Entity> {

      private final EntitySearchField searchField;

      private CustomerConditionPanel(ForeignKeyConditionModel conditionModel, EntityDefinition definition) {
        super(conditionModel);
        setLayout(new BorderLayout());
        setBorder(createTitledBorder(createEmptyBorder(), definition.attributes().definition(Invoice.CUSTOMER_FK).caption()));
        conditionModel.operands().in().value().link(conditionModel.operands().equal());
        searchField = EntitySearchField.builder(conditionModel.inSearchModel())
                .multiSelection()
                .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);
        model().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 List.of(yearValue.component(), monthValue.component());
      }

      @Override
      public void requestInputFocus() {
        monthValue.component().requestFocusInWindow();
      }

      private void updateCondition() {
        model().operands().lower().set(lower());
        model().operands().upper().set(upper());
      }

      private LocalDate lower() {
        int year = yearValue.optional().orElse(LocalDate.now().getYear());
        Month month = monthValue.optional().orElse(JANUARY);

        return LocalDate.of(year, month, 1);
      }

      private LocalDate upper() {
        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();
        }
      }
    }
  }
}

  interface InvoiceLine {
    EntityType TYPE = DOMAIN.entityType("chinook.invoiceline", InvoiceLine.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<Long> INVOICE_ID = TYPE.longColumn("invoice_id");
    Column<Long> TRACK_ID = TYPE.longColumn("track_id");
    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));
    }
  }

  EntityDefinition invoiceLine() {
    return InvoiceLine.TYPE.define(
                    InvoiceLine.ID.define()
                            .primaryKey(),
                    InvoiceLine.INVOICE_ID.define()
                            .column()
                            .nullable(false),
                    InvoiceLine.INVOICE_FK.define()
                            .foreignKey()
                            .referenceDepth(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(InvoiceLine.QUANTITY, InvoiceLine.UNITPRICE)
                            .provider(new InvoiceLineTotalProvider()))
            .keyGenerator(identity())
            .build();
  }

package is.codion.demos.chinook.model;

import is.codion.common.event.Event;
import is.codion.common.observable.Observer;
import is.codion.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
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.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);
    // We populate the unit price when the track is edited
    editor().value(InvoiceLine.TRACK_FK).edited().addConsumer(this::setUnitPrice);
  }

  Observer<Collection<Entity>> totalsUpdated() {
    return totalsUpdatedEvent.observer();
  }

  @Override
  protected Collection<Entity> insert(Collection<Entity> invoiceLines, EntityConnection connection) {
    // Use a transaction to update the invoice totals when an invoice line is inserted
    return transaction(connection, () -> updateTotals(connection.insertSelect(invoiceLines), connection));
  }

  @Override
  protected Collection<Entity> update(Collection<Entity> invoiceLines, EntityConnection connection) {
    // Use a transaction to update the invoice totals when an invoice line is updated
    return transaction(connection, () -> updateTotals(connection.updateSelect(invoiceLines), connection));
  }

  @Override
  protected void delete(Collection<Entity> invoiceLines, EntityConnection connection) {
    // Use a transaction to update the invoice totals when an invoice line is deleted
    transaction(connection, () -> {
      connection.delete(primaryKeys(invoiceLines));
      updateTotals(invoiceLines, connection);
    });
  }

  private void setUnitPrice(Entity track) {
    editor().value(InvoiceLine.UNITPRICE).set(track == null ? null : track.get(Track.UNITPRICE));
  }

  private Collection<Entity> updateTotals(Collection<Entity> invoiceLines, EntityConnection connection) {
    // Get the IDs of the invoices that need their totals updated
    Collection<Long> invoiceIds = distinct(InvoiceLine.INVOICE_ID, invoiceLines);
    // Execute the UPDATE_TOTALS function, which returns the updated invoices
    Collection<Entity> updatedInvoices = connection.execute(Invoice.UPDATE_TOTALS, invoiceIds);
    // Trigger the update totals event with the updated invoices, see InvoiceModel
    totalsUpdatedEvent.accept(updatedInvoices);

    return invoiceLines;
  }
}

package is.codion.demos.chinook.model;

import is.codion.common.user.User;
import is.codion.demos.chinook.domain.ChinookImpl;
import is.codion.demos.chinook.domain.api.Chinook.Customer;
import is.codion.demos.chinook.domain.api.Chinook.Invoice;
import is.codion.demos.chinook.domain.api.Chinook.InvoiceLine;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.domain.entity.Entities;
import is.codion.framework.domain.entity.Entity;

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() {
    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.editor().value(InvoiceLine.INVOICE_FK).set(invoice);
      editModel.editor().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.editor().defaults();
      editModel.editor().value(InvoiceLine.INVOICE_FK).set(invoice);
      editModel.editor().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.set(Track.UNITPRICE, BigDecimal.valueOf(2));
      theCallOfKtulu = connection.updateSelect(theCallOfKtulu);

      editModel.editor().set(invoiceLineBattery);
      editModel.editor().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) {
    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();
  }
}

package is.codion.demos.chinook.ui;

import is.codion.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;
    // We do not want the track to persist when the model is cleared.
    editModel.editor().value(InvoiceLine.TRACK_FK).persist().set(false);
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(InvoiceLine.TRACK_FK);

    createSearchField(InvoiceLine.TRACK_FK)
            .selectorFactory(new TrackSelectorFactory())
            .columns(15);
    createTextField(InvoiceLine.QUANTITY)
            .selectAllOnFocusGained(true)
            .columns(2)
            // Set the INSERT control as the quantity field
            // action, triggering insert on Enter
            .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);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.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)
            // The invoice should not be editable via the popup menu
            .editable(attributes -> attributes.remove(InvoiceLine.INVOICE_FK))
            // We provide a custom component to use when
            // the track is edited via the popup menu.
            .editComponentFactory(InvoiceLine.TRACK_FK, new TrackEditComponentFactory(InvoiceLine.TRACK_FK)));
    table().setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
    setPreferredSize(new Dimension(360, 40));
  }
}

  interface Employee {
    EntityType TYPE = DOMAIN.entityType("chinook.employee", Employee.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> LASTNAME = TYPE.stringColumn("lastname");
    Column<String> FIRSTNAME = TYPE.stringColumn("firstname");
    Column<String> TITLE = TYPE.stringColumn("title");
    Column<Long> REPORTSTO = TYPE.longColumn("reportsto_id");
    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) {
      super.validate(entity, attribute);
      if (attribute.equals(emailColumn)) {
        validateEmail(entity.get(emailColumn));
      }
    }

    private void validateEmail(String email) {
      if (!EMAIL_PATTERN.matcher(email).matches()) {
        throw new ValidationException(emailColumn, email, BUNDLE.getString("invalid_email"));
      }
    }
  }

  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))
            .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();
  }

package is.codion.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.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.key.TransferFocusOnEnter.BACKWARD;
import static is.codion.swing.common.ui.layout.Layouts.flexibleGridLayout;

public final class EmployeeEditPanel extends EntityEditPanel {

  public EmployeeEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    focus().initial().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);
    createComboBox(Employee.REPORTSTO_FK)
            .preferredWidth(120)
            // Only transfer focus backward on Enter, this way
            // the Enter key without any modifiers will trigger
            // the default dialog button, for inserting and updating
            .transferFocusOnEnter(BACKWARD);

    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);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.swing.common.ui.component.table.FilterTableColumnModel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import is.codion.swing.framework.ui.EntityTablePanel;

import static is.codion.swing.framework.ui.EntityDialogs.editEntityDialog;

public final class EmployeeTablePanel extends EntityTablePanel {

  public EmployeeTablePanel(SwingEntityTableModel tableModel) {
    // We provide a EmployeeEditPanel instance, which is then accessible
    // via double click, popup menu (Add/Edit) or keyboard shortcuts:
    // INSERT to add a new employee or CTRL-INSERT to edit the selected one.
    super(tableModel, new EmployeeEditPanel(tableModel.editModel()));
  }

  @Override
  protected void setupControls() {
    // Replace the default EDIT control command with one that sets
    // the initial focus according the selected table column
    control(ControlKeys.EDIT).map(control -> control.copy(this::edit).build());
  }

  private void edit() {
    editEntityDialog(editPanel())
            .owner(this)
            .onShown(this::requestEditFocus)
            .show();
  }

  private void requestEditFocus(EntityEditPanel editPanel) {
    FilterTableColumnModel<Attribute<?>> columnModel = table().columnModel();
    int columnIndex = columnModel.getSelectionModel().getMinSelectionIndex();
    Attribute<?> attribute = columnModel.getColumn(columnIndex).identifier();
    editPanel.focus().request(attribute);
  }
}

  interface Artist {
    EntityType TYPE = DOMAIN.entityType("chinook.artist", Artist.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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();
      }
    }
  }

  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.artist_id = artist.id"""),
                    Artist.NUMBER_OF_TRACKS.define()
                            .subquery("""
                                    SELECT COUNT(*)
                                    FROM chinook.track
                                    JOIN chinook.album ON track.album_id = album.id
                                    WHERE album.artist_id = artist.id"""))
            .keyGenerator(identity())
            .orderBy(ascending(Artist.NAME))
            .stringFactory(Artist.NAME)
            .build();
  }

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Artist;
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 ArtistEditPanel extends EntityEditPanel {

  public ArtistEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(Artist.NAME);

    createTextField(Artist.NAME)
            .columns(18);

    setLayout(gridLayout(1, 1));
    addInputPanel(Artist.NAME);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.Text;
import is.codion.common.model.CancelException;
import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.demos.chinook.model.ArtistTableModel;
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 javax.swing.JOptionPane;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import static is.codion.framework.db.EntityConnection.Count.where;
import static is.codion.swing.common.ui.dialog.Dialogs.progressWorkerDialog;
import static java.lang.System.lineSeparator;
import static java.util.stream.Collectors.joining;
import static javax.swing.JOptionPane.showConfirmDialog;
import static javax.swing.JOptionPane.showMessageDialog;

public final class ArtistTablePanel extends EntityTablePanel {

  public ArtistTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel);
    configurePopupMenu(layout -> layout.clear()
            .control(createCombineControl())
            .separator()
            .defaults());
  }

  private Control createCombineControl() {
    return Control.builder()
            .command(this::combineSelected)
            .caption("Combine...")
            .enabled(tableModel().selection().multiple())
            .build();
  }

  private void combineSelected() {
    List<Entity> selectedArtists = tableModel().selection().items().get();
    Entity artistToKeep = Dialogs.listSelectionDialog(selectedArtists)
            .owner(this)
            .title("Select the artist to keep")
            .comparator(Text.collator())
            .selectSingle()
            .orElseThrow(CancelException::new);

    List<Entity> artistsToDelete = new ArrayList<>(selectedArtists);
    artistsToDelete.remove(artistToKeep);
    int albumCount = tableModel().connection().count(where(Album.ARTIST_FK.in(artistsToDelete)));
    if (confirmCombination(artistsToDelete, artistToKeep, albumCount)) {
      ArtistTableModel tableModel = (ArtistTableModel) tableModel();
      progressWorkerDialog(() -> tableModel.combine(artistsToDelete, artistToKeep))
              .owner(this)
              .title("Updating albums...")
              .onResult(() -> {
                tableModel.onCombined(artistsToDelete, artistToKeep);
                showMessageDialog(this, "Artists combined!");
              })
              .execute();
    }
  }

  private boolean confirmCombination(List<Entity> artistsToDelete, Entity artistToKeep, int albumCount) {
    StringBuilder message = new StringBuilder();
    if (albumCount > 0) {
      message.append("Associate ").append(albumCount).append(" albums(s) ").append(lineSeparator())
              .append("with ").append(artistToKeep).append("?").append(lineSeparator());
    }
    message.append("Delete the following:").append(lineSeparator())
            .append(artistsToDelete.stream()
                    .map(Objects::toString)
                    .collect(joining(lineSeparator()))).append(lineSeparator())
            .append("while keeping: ").append(artistToKeep).append("?");

    return showConfirmDialog(ArtistTablePanel.this, message,
            "Confirm artist combination", JOptionPane.OK_CANCEL_OPTION) == JOptionPane.OK_OPTION;
  }
}

  interface Genre {
    EntityType TYPE = DOMAIN.entityType("chinook.genre", Genre.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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();
      }
    }
  }

  EntityDefinition genre() {
    return Genre.TYPE.define(
                    Genre.ID.define()
                            .primaryKey(),
                    Genre.NAME.define()
                            .column()
                            .searchable(true)
                            .nullable(false)
                            .maximumLength(120))
            .keyGenerator(identity())
            .orderBy(ascending(Genre.NAME))
            .stringFactory(Genre.NAME)
            .smallDataset(true)
            .build();
  }

package is.codion.demos.chinook.ui;

import is.codion.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() {
    focus().initial().set(Genre.NAME);

    createTextField(Genre.NAME);

    setLayout(gridLayout(1, 1));
    addInputPanel(Genre.NAME);
  }
}

  interface MediaType {
    EntityType TYPE = DOMAIN.entityType("chinook.mediatype", MediaType.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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();
      }
    }
  }

  EntityDefinition mediaType() {
    return MediaType.TYPE.define(
                    MediaType.ID.define()
                            .primaryKey(),
                    MediaType.NAME.define()
                            .column()
                            .nullable(false)
                            .maximumLength(120))
            .keyGenerator(identity())
            .stringFactory(MediaType.NAME)
            .smallDataset(true)
            .build();
  }

package is.codion.demos.chinook.ui;

import is.codion.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() {
    focus().initial().set(MediaType.NAME);

    createTextField(MediaType.NAME);

    setLayout(gridLayout(1, 1));
    addInputPanel(MediaType.NAME);
  }
}

  interface Artist {
    EntityType TYPE = DOMAIN.entityType("chinook.artist", Artist.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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();
      }
    }
  }

  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.artist_id = artist.id"""),
                    Artist.NUMBER_OF_TRACKS.define()
                            .subquery("""
                                    SELECT COUNT(*)
                                    FROM chinook.track
                                    JOIN chinook.album ON track.album_id = album.id
                                    WHERE album.artist_id = artist.id"""))
            .keyGenerator(identity())
            .orderBy(ascending(Artist.NAME))
            .stringFactory(Artist.NAME)
            .build();
  }

  interface Album {
    EntityType TYPE = DOMAIN.entityType("chinook.album", Album.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> TITLE = TYPE.stringColumn("title");
    Column<Long> ARTIST_ID = TYPE.longColumn("artist_id");
    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();
      }
    }
  }

  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.album_id = album.id"""),
                    Album.TAGS.define()
                            .column()
                            .columnClass(Array.class, new TagsConverter(), ResultSet::getArray),
                    Album.RATING.define()
                            .subquery("""
                                    SELECT AVG(rating)
                                    FROM chinook.track
                                    WHERE track.album_id = album.id"""))
            .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);
      }
    }
  }

package is.codion.demos.chinook.model;

import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnectionProvider;
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));
    detailModels().add(trackModel);
    TrackEditModel trackEditModel = (TrackEditModel) trackModel.editModel();
    trackEditModel.initializeComboBoxModels(Track.MEDIATYPE_FK, Track.GENRE_FK);
    // We refresh albums which rating may have changed, due to a track rating being updated
    trackEditModel.ratingUpdated().addConsumer(tableModel()::refresh);
  }
}

package is.codion.demos.chinook.model;

import is.codion.common.user.User;
import is.codion.demos.chinook.domain.ChinookImpl;
import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
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() {
    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().condition().get(Album.TITLE).set().equalTo(MASTER_OF_PUPPETS);
      albumTableModel.items().refresh();
      assertEquals(1, albumTableModel.items().count());

      List<Entity> modifiedTracks = connection.select(Track.ALBUM_FK.equalTo(masterOfPuppets)).stream()
              .peek(track -> track.set(Track.RATING, 10))
              .toList();

      // Update the tracks using the edit model
      albumModel.detailModels().get(Track.TYPE).editModel().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().get(0).get(Album.RATING));

      connection.rollbackTransaction();
    }
  }

  private static EntityConnectionProvider createConnectionProvider() {
    return LocalEntityConnectionProvider.builder()
            .domain(new ChinookImpl())
            .user(User.parse("scott:tiger"))
            .build();
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.demos.chinook.model.TrackTableModel;
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.detailModels().get(Track.TYPE);
    EntityPanel trackPanel = new EntityPanel(trackModel,
            new TrackEditPanel(trackModel.editModel(), trackModel.tableModel().selection()),
            new TrackTablePanel((TrackTableModel) trackModel.tableModel()));

    detailPanels().add(trackPanel);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.demos.chinook.domain.api.Chinook.Artist;
import is.codion.swing.common.model.component.list.FilterListModel;
import is.codion.swing.common.ui.component.list.FilterList;
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.JPanel;
import java.awt.BorderLayout;
import java.util.List;

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() {
    focus().initial().set(Album.ARTIST_FK);

    createSearchField(Album.ARTIST_FK)
            .columns(15)
            // We provide a edit panel supplier, which enables
            // keyboard shortcuts for adding a new artist (INSERT)
            // or editing the currently selected one (CTRL-INSERT).
            .editPanel(this::createArtistEditPanel);
    createTextField(Album.TITLE)
            .columns(15);
    // We create a custom component for the album tags,
    // the JList it is based on is automatically associated
    // with Album.TAGS, since we use the createList() method.
    AlbumTagPanel albumTagPanel = createAlbumTagPanel();
    // We create a custom component for the album cover art
    CoverArtPanel coverArtPanel = new CoverArtPanel(editModel().editor().value(Album.COVER));
    // We set the CoverArtPanel as the component for Album.COVER,
    // so that it will appear in the input component selection dialog
    component(Album.COVER).set(coverArtPanel);

    JPanel centerPanel = flexibleGridLayoutPanel(2, 2)
            .add(createInputPanel(Album.ARTIST_FK))
            .add(createInputPanel(Album.TITLE))
            .add(createInputPanel(Album.TAGS, albumTagPanel))
            .add(createInputPanel(Album.COVER))
            .build();

    setLayout(borderLayout());
    add(centerPanel, BorderLayout.CENTER);
  }

  private AlbumTagPanel createAlbumTagPanel() {
    // We create JList based value for the album tags.
    ComponentValue<List<String>, FilterList<String>> tagsValue =
            createList(FilterListModel.<String>filterListModel())
                    // The value should be based on the items in
                    // the list as opposed to the selected items
                    .items(Album.TAGS)
                    .buildValue();
    // We then base the custom AlbumTagPanel component
    // on the above component value
    return new AlbumTagPanel(tagsValue);
  }

  private EntityEditPanel createArtistEditPanel() {
    return new ArtistEditPanel(new SwingEntityEditModel(Artist.TYPE, editModel().connectionProvider()));
  }
}

package is.codion.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.dialog.Dialogs;
import is.codion.swing.framework.ui.icon.FrameworkIcons;

import org.kordamp.ikonli.foundation.Foundation;

import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.GridLayout;
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.*;
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 JButton addButton;
  private final JButton removeButton;
  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.isNull());
    this.imagePanel = createImagePanel();
    this.addButton = button(Control.builder()
            .command(this::addCover)
            .smallIcon(ICONS.get(Foundation.PLUS)))
            .transferFocusOnEnter(true)
            .build();
    this.removeButton = button(Control.builder()
            .command(this::removeCover)
            .smallIcon(ICONS.get(Foundation.MINUS)))
            .transferFocusOnEnter(true)
            .enabled(imageSelected)
            .build();
    this.centerPanel = createCenterPanel();
    add(centerPanel, BorderLayout.CENTER);
    bindEvents();
  }

  @Override
  public boolean requestFocusInWindow() {
    // The panel itself is not focusable,
    // request focus for the add button instead
    return addButton.requestFocusInWindow();
  }

  private JPanel createCenterPanel() {
    return borderLayoutPanel()
            .preferredSize(EMBEDDED_SIZE)
            .centerComponent(imagePanel)
            .southComponent(borderLayoutPanel()
                    .eastComponent(panel(new GridLayout(1, 2, 0, 0))
                            .addAll(addButton, removeButton)
                            .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 addCover() 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());
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.model.filter.FilterModel;
import is.codion.common.state.State;
import is.codion.framework.i18n.FrameworkMessages;
import is.codion.swing.common.ui.component.list.FilterList;
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.JPanel;
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>, FilterList<String>> tagsValue;
  private final FilterModel.Items<String> tagItems;
  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.get(Foundation.PLUS))
          .build();
  private final Control removeTagControl = Control.builder()
          .command(this::removeTag)
          .smallIcon(ICONS.get(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();

  /**
   * @param tagsValue the list value providing the list component
   */
  AlbumTagPanel(ComponentValue<List<String>, FilterList<String>> tagsValue) {
    super(borderLayout());
    this.tagsValue = tagsValue;
    this.tagsValue.component().addListSelectionListener(new UpdateSelectionEmptyState());
    this.tagItems = tagsValue.component().model().items();
    add(createCenterPanel(), BorderLayout.CENTER);
    setupKeyEvents();
  }

  ComponentValue<List<String>, FilterList<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))
            .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() {
    State tagNull = State.state(true);
    tagItems.add(inputDialog(stringField()
            .consumer(tag -> tagNull.set(tag == null)))
            .owner(this)
            .title(FrameworkMessages.add())
            .valid(tagNull.not())
            .show());
  }

  private void removeTag() {
    tagsValue.component().getSelectedValuesList().forEach(tagItems::remove);
  }

  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] != tagItems.visible().count() - 1) {
        moveTagsDown(selected);
        moveSelectionDown(selected);
      }
    }
    finally {
      movingTags.set(false);
    }
  }

  private void moveTagsUp(int[] selected) {
    for (int i = 0; i < selected.length; i++) {
      tagItems.visible().add(selected[i] - 1, tagItems.visible().remove(selected[i]));
    }
  }

  private void moveTagsDown(int[] selected) {
    for (int i = selected.length - 1; i >= 0; i--) {
      tagItems.visible().add(selected[i] + 1, tagItems.visible().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());
      }
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.plugin.imagepanel.NavigableImagePanel;
import is.codion.swing.common.model.component.list.FilterListModel;
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.EditComponentFactory;

import javax.imageio.ImageIO;
import javax.swing.JDialog;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.List;

import static is.codion.demos.chinook.ui.TrackTablePanel.RATINGS;

public final class AlbumTablePanel extends EntityTablePanel {

  private final NavigableImagePanel coverPanel;

  public AlbumTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel, config -> config
            // A custom input component for editing Album.TAGS
            .editComponentFactory(Album.TAGS, new TagEditComponentFactory())
            // Custom cell renderer for Album.RATING
            // rendering the rating as stars, i.e. *****
            .cellRenderer(Album.RATING, EntityTableCellRenderer.builder(Album.RATING, tableModel)
                    .string(RATINGS::get)
                    .toolTipData(true)
                    .build()));
    coverPanel = new NavigableImagePanel();
    coverPanel.setPreferredSize(Windows.screenSizeRatio(0.5));
    table().doubleClick().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.isNull(Album.COVER))
            .ifPresent(album -> displayCover(album.get(Album.TITLE), album.get(Album.COVER)));
  }

  private void displayCover(String title, byte[] coverBytes) {
    coverPanel.setImage(readImage(coverBytes));
    if (coverPanel.isShowing()) {
      JDialog dialog = Utilities.parentDialog(coverPanel);
      dialog.setTitle(title);
      dialog.toFront();
    }
    else {
      Dialogs.componentDialog(coverPanel)
              .owner(Utilities.parentWindow(this))
              .title(title)
              .modal(false)
              .onClosed(_ -> coverPanel.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 EditComponentFactory<List<String>, AlbumTagPanel> {

    @Override
    public ComponentValue<List<String>, AlbumTagPanel> component(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(FilterListModel.<String>filterListModel())
              // A list component value based on the items in
              // the model, as opposed to the selected items
              .items()
              // The initial tags to display
              .value(tags)
              .buildValue()));
    }

    @Override
    protected List<String> getComponentValue() {
      return component().tagsValue().get();
    }

    @Override
    protected void setComponentValue(List<String> value) {
      component().tagsValue().set(value);
    }
  }
}

  interface Track {
    EntityType TYPE = DOMAIN.entityType("chinook.track", Track.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<Long> ALBUM_ID = TYPE.longColumn("album_id");
    Column<String> ARTIST_NAME = TYPE.stringColumn("artist_name");
    Column<Long> MEDIATYPE_ID = TYPE.longColumn("mediatype_id");
    Column<Long> GENRE_ID = TYPE.longColumn("genre_id");
    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<Integer> PLAY_COUNT = TYPE.integerColumn("play_count");
    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),
                      track.get(ARTIST_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),
                      track.get(PLAY_COUNT));
    }

    record RaisePriceParameters(Collection<Long> trackIds, BigDecimal priceIncrease) implements Serializable {

      public RaisePriceParameters {
        requireNonNull(trackIds);
        requireNonNull(priceIncrease);
      }
    }

    record Dto(Long id, String name, String artistName, Album.Dto album,
               Genre.Dto genre, MediaType.Dto mediaType,
               Integer milliseconds, Integer rating,
               BigDecimal unitPrice, Integer playCount) {

      public Entity entity(Entities entities) {
        return entities.builder(TYPE)
                .with(ID, id)
                .with(NAME, name)
                .with(ARTIST_NAME, artistName)
                .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)
                .with(PLAY_COUNT, playCount)
                .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();
    }
  }

  EntityDefinition track() {
    return Track.TYPE.define(
                    Track.ID.define()
                            .primaryKey()
                            // Ambiguous column due to join
                            .expression("track.id"),
                    Track.ALBUM_ID.define()
                            .column()
                            .nullable(false),
                    Track.ALBUM_FK.define()
                            .foreignKey()
                            .referenceDepth(2)
                            .attributes(Album.ARTIST_FK, Album.TITLE),
                    Track.ARTIST_NAME.define()
                            .column()
                            // Ambiguous column due to join
                            .expression("artist.name")
                            // Read-only column from a joined table
                            .readOnly(true),
                    Track.NAME.define()
                            .column()
                            // Ambiguous column due to join
                            .expression("track.name")
                            .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.PLAY_COUNT.define()
                            .column()
                            .nullable(false)
                            .defaultValue(0),
                    Track.RANDOM.define()
                            .column()
                            .readOnly(true)
                            .selected(false))
            .keyGenerator(identity())
            .selectQuery(EntitySelectQuery.builder()
                    // Override the default FROM clause, joining
                    // the ALBUM and ARTIST tables in order to
                    // have the ARTIST.NAME column available
                    .from("""
                            chinook.track
                            JOIN chinook.album ON track.album_id = album.id
                            JOIN chinook.artist ON album.artist_id = artist.id""")
                    .build())
            .orderBy(ascending(Track.NAME))
            // Implement a custom condition for specifying
            // tracks that are not in a given playlist
            .condition(Track.NOT_IN_PLAYLIST, (_, _) -> """
                    track.id NOT IN (
                        SELECT track_id
                        FROM chinook.playlisttrack
                        WHERE playlist_id = ?
                    )""")
            .stringFactory(Track.NAME)
            .build();
  }

  private static final class RaisePriceFunction implements DatabaseFunction<EntityConnection, RaisePriceParameters, Collection<Entity>> {

    @Override
    public Collection<Entity> execute(EntityConnection entityConnection,
                                      RaisePriceParameters parameters) {
      Select select = where(Track.ID.in(parameters.trackIds()))
              .forUpdate()
              .build();

      return entityConnection.updateSelect(entityConnection.select(select).stream()
              .map(track -> raisePrice(track, parameters.priceIncrease()))
              .toList());
    }

    private static Entity raisePrice(Entity track, BigDecimal priceIncrease) {
      track.set(Track.UNITPRICE, track.get(Track.UNITPRICE).add(priceIncrease));

      return track;
    }
  }

package is.codion.demos.chinook.model;

import is.codion.common.event.Event;
import is.codion.common.observable.Observer;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityEditModel;

import java.util.Collection;
import java.util.Set;

import static java.util.stream.Collectors.toSet;

public final class TrackEditModel extends SwingEntityEditModel {

  private final Event<Collection<Entity.Key>> ratingUpdated = Event.event();

  public TrackEditModel(EntityConnectionProvider connectionProvider) {
    super(Track.TYPE, connectionProvider);
    // Creates and populates the combo box models for the given foreign keys, otherwise this
    // would happen when the associated combo boxes are created, as the UI is initialized.
    initializeComboBoxModels(Track.MEDIATYPE_FK, Track.GENRE_FK);
  }

  Observer<Collection<Entity.Key>> ratingUpdated() {
    return ratingUpdated.observer();
  }

  @Override
  protected Collection<Entity> update(Collection<Entity> entities, EntityConnection connection) {
    // Find tracks which rating has been modified and collect the
    // album keys, in order to propagate to the ratingUpdated event
    Set<Entity.Key> albumKeys = entities.stream()
            .filter(entity -> entity.type().equals(Track.TYPE))
            .filter(track -> track.modified(Track.RATING))
            .map(track -> track.key(Track.ALBUM_FK))
            .collect(toSet());
    Collection<Entity> updated = super.update(entities, connection);
    if (!albumKeys.isEmpty()) {
      ratingUpdated.accept(albumKeys);
    }

    return updated;
  }
}

package is.codion.demos.chinook.model;

import is.codion.common.value.Value.Validator;
import is.codion.demos.chinook.domain.api.Chinook.Track.RaisePriceParameters;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.ForeignKey;
import is.codion.framework.model.ForeignKeyConditionModel;
import is.codion.swing.framework.model.SwingEntityConditionModelFactory;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.model.SwingForeignKeyConditionModel;

import java.math.BigDecimal;
import java.util.Collection;

import static is.codion.demos.chinook.domain.api.Chinook.Track;
import static is.codion.framework.model.EntityQueryModel.entityQueryModel;
import static is.codion.framework.model.EntityTableConditionModel.entityTableConditionModel;

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(entityTableConditionModel(Track.TYPE, connectionProvider,
                    new TrackColumnConditionFactory(connectionProvider))));
    editable().set(true);
    configureLimit();
  }

  public void raisePriceOfSelected(BigDecimal increase) {
    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(items()::refresh);
    queryModel().limit().addValidator(new LimitValidator());
  }

  private static final class LimitValidator implements 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 SwingEntityConditionModelFactory {

    private TrackColumnConditionFactory(EntityConnectionProvider connectionProvider) {
      super(Track.TYPE, connectionProvider);
    }

    @Override
    protected ForeignKeyConditionModel conditionModel(ForeignKey foreignKey) {
      if (foreignKey.equals(Track.MEDIATYPE_FK)) {
        return SwingForeignKeyConditionModel.builder()
                .equalComboBoxModel(createEqualComboBoxModel(Track.MEDIATYPE_FK))
                .build();
      }

      return super.conditionModel(foreignKey);
    }
  }
}

package is.codion.demos.chinook.model;

import is.codion.common.user.User;
import is.codion.demos.chinook.domain.ChinookImpl;
import is.codion.demos.chinook.domain.api.Chinook.Album;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
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
  void raisePriceOfSelected() {
    try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
      Entity masterOfPuppets = connectionProvider.connection()
              .selectSingle(Album.TITLE.equalTo("Master Of Puppets"));

      TrackTableModel trackTableModel = new TrackTableModel(connectionProvider);
      trackTableModel.queryModel().condition()
            .get(Track.ALBUM_FK).set().equalTo(masterOfPuppets);

      trackTableModel.items().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();
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.ui.DurationComponentValue.DurationPanel;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.model.component.list.FilterListSelection;
import is.codion.swing.common.ui.key.KeyEvents;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;

import javax.swing.JPanel;

import static is.codion.demos.chinook.domain.api.Chinook.*;
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.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 FilterListSelection<Entity> tableSelection;
  private final UpdateCommand updateAndDecrementSelectedIndexes;
  private final UpdateCommand updateAndIncrementSelectedIndexes;

  public TrackEditPanel(SwingEntityEditModel editModel, FilterListSelection<Entity> tableSelection) {
    super(editModel);
    this.tableSelection = tableSelection;
    this.updateAndDecrementSelectedIndexes = updateCommand()
            .onUpdate(tableSelection.indexes()::decrement)
            .build();
    this.updateAndIncrementSelectedIndexes = updateCommand()
            .onUpdate(tableSelection.indexes()::increment)
            .build();
    addKeyEvents();
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(Track.ALBUM_FK);

    createSearchField(Track.ALBUM_FK);
    createTextField(Track.NAME)
            .columns(12);
    createComboBoxPanel(Track.MEDIATYPE_FK, this::createMediaTypeEditPanel)
            .preferredWidth(160)
            .includeAddButton(true)
            .includeEditButton(true);
    createComboBoxPanel(Track.GENRE_FK, this::createGenreEditPanel)
            .preferredWidth(160)
            .includeAddButton(true)
            .includeEditButton(true);
    createTextFieldPanel(Track.COMPOSER)
            .columns(12);

    DurationPanel durationPanel = createDurationPanel();
    component(Track.MILLISECONDS).set(durationPanel);

    createIntegerField(Track.BYTES)
            .columns(6);
    createIntegerSpinner(Track.RATING)
            .columns(2);
    createTextField(Track.UNITPRICE)
            .columns(4);
    createIntegerField(Track.PLAY_COUNT)
            .columns(4);

    JPanel genreMediaTypePanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Track.GENRE_FK))
            .add(createInputPanel(Track.MEDIATYPE_FK))
            .build();

    JPanel durationInputPanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Track.BYTES))
            .add(durationPanel)
            .build();

    JPanel unitPricePanel = flexibleGridLayoutPanel(1, 3)
            .add(createInputPanel(Track.RATING))
            .add(createInputPanel(Track.UNITPRICE))
            .add(createInputPanel(Track.PLAY_COUNT))
            .build();

    setLayout(flexibleGridLayout(4, 2));
    addInputPanel(Track.ALBUM_FK);
    addInputPanel(Track.NAME);
    add(genreMediaTypePanel);
    addInputPanel(Track.COMPOSER);
    add(durationInputPanel);
    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 DurationPanel createDurationPanel() {
    return new DurationComponentValue(editModel().editor().value(Track.MILLISECONDS)).component();
  }

  private void addKeyEvents() {
    // We add key events for CTRL-DOWN and CTRL-UP
    // for incrementing and decrementing the selected
    // index, respectively, after updating the selected
    // item in case it is modified.
    KeyEvents.builder()
            // Set the condition
            .condition(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
            // and modifiers
            .modifiers(CTRL_DOWN_MASK)
            // set a keycode
            .keyCode(VK_UP)
            // and an action
            .action(command(this::decrementSelection))
            // and enable
            .enable(this)
            // set a new keycode
            .keyCode(VK_DOWN)
            // and a new action
            .action(command(this::incrementSelection))
            // and enable
            .enable(this);
  }

  private void decrementSelection() {
    if (editModel().editor().modified().get()) {
      updateAndDecrementSelectedIndexes.execute();
    }
    else {
      tableSelection.indexes().decrement();
    }
  }

  private void incrementSelection() {
    if (editModel().editor().modified().get()) {
      updateAndIncrementSelectedIndexes.execute();
    }
    else {
      tableSelection.indexes().increment();
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.demos.chinook.model.TrackTableModel;
import is.codion.demos.chinook.ui.DurationComponentValue.DurationPanel;
import is.codion.framework.domain.entity.EntityDefinition;
import is.codion.framework.domain.entity.attribute.AttributeDefinition;
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.value.ComponentValue;
import is.codion.swing.common.ui.control.Control;
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.EditComponentFactory;

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.demos.chinook.ui.DurationComponentValue.minutes;
import static is.codion.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.common.ui.dialog.Dialogs.inputDialog;
import static is.codion.swing.common.ui.key.KeyEvents.keyStroke;
import static is.codion.swing.framework.ui.component.EntityComponents.entityComponents;
import static java.awt.event.KeyEvent.VK_INSERT;
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
            // Custom component for editing track ratings
            .editComponentFactory(Track.RATING, new RatingEditComponentFactory())
            // Custom component for editing track durations
            .editComponentFactory(Track.MILLISECONDS, new DurationEditComponentFactory())
            // Custom cell renderer for ratings
            .cellRenderer(Track.RATING, ratingRenderer(tableModel))
            // Custom cell renderer for track duration (min:sec)
            .cellRenderer(Track.MILLISECONDS, durationRenderer(tableModel))
            // Custom cell editor for track ratings
            .cellEditor(Track.RATING, ratingEditor(tableModel.entityDefinition()))
            // Custom cell editor for track durations (min:sec:ms)
            .cellEditor(Track.MILLISECONDS, durationEditor())
            // Start editing when the INSERT key is pressed
            .table(table ->
                    table.startEditing(keyStroke(VK_INSERT)))
            .includeLimitMenu(true));
    // Add a custom control to the top of the table popup menu.
    // Start by clearing the popup menu layout
    configurePopupMenu(layout -> layout.clear()
            // add our custom control
            .control(Control.builder()
                    .command(this::raisePriceOfSelected)
                    .caption(BUNDLE.getString("raise_price") + "...")
                    .enabled(tableModel().selection().empty().not()))
            // and a separator
            .separator()
            // and add all the default controls
            .defaults());
  }

  private void raisePriceOfSelected() {
    TrackTableModel tableModel = (TrackTableModel) tableModel();
    tableModel.raisePriceOfSelected(getAmountFromUser());
  }

  private BigDecimal getAmountFromUser() {
    return inputDialog(bigDecimalField()
            .nullable(false)
            .minimumValue(0))
            .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 RatingEditComponentFactory
          implements EditComponentFactory<Integer, JSpinner> {

    @Override
    public ComponentValue<Integer, JSpinner> component(SwingEntityEditModel editModel,
                                                       Integer value) {
      return ratingSpinner(editModel.entityDefinition())
              .value(value)
              .buildValue();
    }
  }

  private static final class DurationEditComponentFactory
          implements EditComponentFactory<Integer, DurationPanel> {

    @Override
    public Optional<String> caption(AttributeDefinition<Integer> attribute) {
      return Optional.empty();
    }

    @Override
    public ComponentValue<Integer, DurationPanel> component(SwingEntityEditModel editModel, Integer value) {
      DurationComponentValue durationValue = new DurationComponentValue(false);
      durationValue.set(value);

      return durationValue;
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.state.ObservableState;
import is.codion.framework.model.EntityEditModel.EditorValue;
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(EditorValue<Integer> millisecondsValue) {
    this(new DurationPanel(false, millisecondsValue.valid(), millisecondsValue.modified()));
    link(millisecondsValue);
  }

  DurationComponentValue(boolean cellEditor) {
    this(new DurationPanel(cellEditor));
  }

  DurationComponentValue(DurationPanel panel) {
    super(panel);
    component().minutesField.observable().addListener(this::notifyListeners);
    component().secondsField.observable().addListener(this::notifyListeners);
    component().millisecondsField.observable().addListener(this::notifyListeners);
  }

  @Override
  protected Integer getComponentValue() {
    Integer minutes = component().minutesField.get();
    Integer seconds = component().secondsField.get();
    Integer milliseconds = component().millisecondsField.get();
    if (minutes == null && seconds == null && milliseconds == null) {
      return null;
    }

    return (int) ofMinutes(component().minutesField.optional().orElse(0))
            .plusSeconds(component().secondsField.optional().orElse(0))
            .plusMillis(component().millisecondsField.optional().orElse(0))
            .toMillis();
  }

  @Override
  protected void setComponentValue(Integer milliseconds) {
    component().minutesField.set(minutes(milliseconds));
    component().secondsField.set(seconds(milliseconds));
    component().millisecondsField.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());

    private final NumberField<Integer> minutesField;
    private final NumberField<Integer> secondsField;
    private final NumberField<Integer> millisecondsField;

    private final JLabel minLabel = new JLabel(BUNDLE.getString("min"));
    private final JLabel secLabel = new JLabel(BUNDLE.getString("sec"));
    private final JLabel msLabel = new JLabel(BUNDLE.getString("ms"));

    private DurationPanel(boolean cellEditor) {
      this(cellEditor, null, null);
    }

    private DurationPanel(boolean cellEditor, ObservableState valid, ObservableState modified) {
      super(borderLayout());
      minutesField = integerField()
              .transferFocusOnEnter(true)
              .selectAllOnFocusGained(true)
              .modifiedIndicator(modified)
              .validIndicator(valid)
              .label(minLabel)
              .columns(2)
              .build();
      secondsField = integerField()
              .valueRange(0, 59)
              .transferFocusOnEnter(true)
              .selectAllOnFocusGained(true)
              .silentValidation(true)
              .modifiedIndicator(modified)
              .validIndicator(valid)
              .label(secLabel)
              .columns(2)
              .build();
      millisecondsField = integerField()
              .valueRange(0, 999)
              .transferFocusOnEnter(!cellEditor)
              .selectAllOnFocusGained(true)
              .silentValidation(true)
              .modifiedIndicator(modified)
              .validIndicator(valid)
              .label(msLabel)
              .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, 0)
              .add(minutesField)
              .add(secondsField)
              .add(millisecondsField)
              .build(), BorderLayout.CENTER);
    }

    private void initializeInputPanel() {
      add(borderLayoutPanel()
              .northComponent(gridLayoutPanel(1, 0)
                      .add(minLabel)
                      .add(secLabel)
                      .add(msLabel)
                      .build())
              .centerComponent(gridLayoutPanel(1, 0)
                      .add(minutesField)
                      .add(secondsField)
                      .add(millisecondsField)
                      .build())
              .build());
    }
  }
}

  interface Playlist {
    EntityType TYPE = DOMAIN.entityType("chinook.playlist", Playlist.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    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 {}
  }

  EntityDefinition playlist() {
    return Playlist.TYPE.define(
                    Playlist.ID.define()
                            .primaryKey(),
                    Playlist.NAME.define()
                            .column()
                            .searchable(true)
                            .nullable(false)
                            .maximumLength(120))
            .keyGenerator(identity())
            .orderBy(ascending(Playlist.NAME))
            .stringFactory(Playlist.NAME)
            .build();
  }

  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) {
      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) {
      Entity playlist = connection.insertSelect(createPlaylist(playlistName));

      connection.insert(createPlaylistTracks(playlist.primaryKey().value(), 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) {
      return connection.select(Track.ID,
              where(Track.GENRE_FK.in(genres))
                      .orderBy(ascending(Track.RANDOM))
                      .limit(noOfTracks)
                      .build());
    }
  }

package is.codion.demos.chinook.model;

import is.codion.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
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) {
    // We delete all playlist tracks along
    // with the playlist, within a transaction
    transaction(connection, () -> {
      connection.delete(PlaylistTrack.PLAYLIST_FK.in(playlists));
      connection.delete(primaryKeys(playlists));
    });
  }
}

package is.codion.demos.chinook.model;

import is.codion.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
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) {
    EntityConnection connection = connection();
    Entity randomPlaylist = transaction(connection, () -> connection.execute(Playlist.RANDOM_PLAYLIST, parameters));
    items().visible().add(0, randomPlaylist);
    selection().item().set(randomPlaylist);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.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()),
            // We override initializeUI(), so we don't need a detail layout
            config -> config.detailLayout(DetailLayout.NONE));

    SwingEntityModel playlistTrackModel =
            playlistModel.detailModels().get(PlaylistTrack.TYPE);
    EntityPanel playlistTrackPanel =
            new EntityPanel(playlistTrackModel,
                    new PlaylistTrackTablePanel(playlistTrackModel.tableModel()));

    // We still add the detail panel, for keyboard navigation
    detailPanels().add(playlistTrackPanel);
  }

  @Override
  protected void initializeUI() {
    setLayout(borderLayout());
    add(splitPane()
            .leftComponent(mainPanel())
            .rightComponent(detailPanels().get(PlaylistTrack.TYPE).initialize())
            .continuousLayout(true)
            .build(), BorderLayout.CENTER);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.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
            // Skip confirmation when updating
            .updateConfirmer(Confirmer.NONE));
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(Playlist.NAME);

    setLayout(borderLayout());
    add(borderLayoutPanel()
            .westComponent(createLabel(Playlist.NAME).build())
            .centerComponent(createTextField(Playlist.NAME)
                    .transferFocusOnEnter(false)
                    .columns(20)
                    .build())
            .border(new EmptyBorder(Layouts.GAP.get(), Layouts.GAP.get(), 0, Layouts.GAP.get()))
            .build(), BorderLayout.CENTER);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.demos.chinook.model.PlaylistTableModel;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.swing.common.ui.component.value.AbstractComponentValue;
import is.codion.swing.common.ui.control.Control;
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.common.ui.dialog.Dialogs.inputDialog;
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) {
    // We provide an edit panel, which becomes available via
    // double click and keyboard shortcuts, instead of embedding it
    super(tableModel, new PlaylistEditPanel(tableModel.editModel()));
    // Add a custom control, for creating a random playlist,
    // positioned below the standard DELETE control.
    // Start by clearing the popup menu layout
    configurePopupMenu(layout -> layout.clear()
            // add all default controls up to and including DELETE
            .defaults(DELETE)
            // and a separator
            .separator()
            // and our custom control
            .control(Control.builder()
                    .command(this::randomPlaylist)
                    .caption(BUNDLE.getString("random_playlist"))
                    .smallIcon(FrameworkIcons.instance().add()))
            // and a separator
            .separator()
            // and the remaining default controls
            .defaults());
  }

  @Override
  protected void setupControls() {
    // No need for the edit attribute controls in the popup menu
    control(EDIT_ATTRIBUTE_CONTROLS).clear();
  }

  private void randomPlaylist() {
    RandomPlaylistParametersValue playlistParametersValue = new RandomPlaylistParametersValue(tableModel().connectionProvider());
    RandomPlaylistParameters randomPlaylistParameters = inputDialog(playlistParametersValue)
            .owner(this)
            .title(BUNDLE.getString("random_playlist"))
            .valid(playlistParametersValue.component().parametersValid())
            .show();

    PlaylistTableModel 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 */}
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.state.ObservableState;
import is.codion.common.state.State;
import is.codion.common.value.Value;
import is.codion.common.value.ValueList;
import is.codion.demos.chinook.domain.api.Chinook.Genre;
import is.codion.demos.chinook.domain.api.Chinook.Playlist.RandomPlaylistParameters;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.component.Components;
import is.codion.swing.common.ui.component.list.FilterList;
import is.codion.swing.common.ui.component.text.NumberField;

import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import java.awt.BorderLayout;
import java.util.Collection;
import java.util.ResourceBundle;

import static is.codion.common.Text.nullOrEmpty;
import static is.codion.framework.db.EntityConnection.Select.all;
import static is.codion.framework.domain.entity.OrderBy.ascending;
import static is.codion.swing.common.model.component.list.FilterListModel.filterListModel;
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 FilterList<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);
  }

  ObservableState parametersValid() {
    return model.parametersValid.observable();
  }

  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 FilterList<Entity> createGenreList(EntityConnectionProvider connectionProvider) {
    return Components.list(filterListModel(allGenres(connectionProvider)))
            .selectedItems(model.genres)
            .visibleRowCount(5)
            .build();
  }

  private static Collection<Entity> allGenres(EntityConnectionProvider connectionProvider) {
    return connectionProvider.connection().select(all(Genre.TYPE)
            .orderBy(ascending(Genre.NAME))
            .build());
  }

  private static final class RandomPlaylistParametersModel {

    private final Value<String> playlistName = Value.nullable();
    private final Value<Integer> noOfTracks = Value.nullable();
    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(valid());
    }

    private boolean valid() {
      if (nullOrEmpty(playlistName.get())) {
        return false;
      }
      if (noOfTracks.isNull()) {
        return false;
      }
      if (genres.isEmpty()) {
        return false;
      }

      return true;
    }
  }
}

  interface PlaylistTrack {
    EntityType TYPE = DOMAIN.entityType("chinook.playlisttrack", PlaylistTrack.class.getName());

    Column<Long> ID = TYPE.longColumn("id");
    Column<Long> PLAYLIST_ID = TYPE.longColumn("playlist_id");
    Column<Long> TRACK_ID = TYPE.longColumn("track_id");
    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);
  }

  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()
                            .referenceDepth(3),
                    PlaylistTrack.ALBUM.define()
                            .denormalized(PlaylistTrack.TRACK_FK, Track.ALBUM_FK))
            .keyGenerator(identity())
            .stringFactory(StringFactory.builder()
                    .value(PlaylistTrack.PLAYLIST_FK)
                    .text(" - ")
                    .value(PlaylistTrack.TRACK_FK)
                    .build())
            .build();
  }

package is.codion.demos.chinook.model;

import is.codion.demos.chinook.domain.api.Chinook.Playlist;
import is.codion.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.demos.chinook.domain.api.Chinook.Track;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.condition.Condition;
import is.codion.swing.framework.model.SwingEntityEditModel;

public final class PlaylistTrackEditModel extends SwingEntityEditModel {

  public PlaylistTrackEditModel(EntityConnectionProvider connectionProvider) {
    super(PlaylistTrack.TYPE, connectionProvider);
    // So that the track editor value is cleared after a track is added
    editor().value(PlaylistTrack.TRACK_FK).persist().set(false);
    // Set the search model condition, so the search results
    // won't contain tracks already in the selected playlist
    searchModel(PlaylistTrack.TRACK_FK).condition().set(this::excludePlaylistTracks);
  }

  private Condition excludePlaylistTracks() {
    Entity playlist = editor().value(PlaylistTrack.PLAYLIST_FK).getOrThrow();

    // Use a custom subquery based condition, see domain model implementation
    return Track.NOT_IN_PLAYLIST.get(Playlist.ID, playlist.get(Playlist.ID));
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.PlaylistTrack;
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 PlaylistTrackEditPanel extends EntityEditPanel {

  PlaylistTrackEditPanel(SwingEntityEditModel editModel) {
    super(editModel, config -> config
            // Skip confirmation when deleting
            .deleteConfirmer(Confirmer.NONE));
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(PlaylistTrack.TRACK_FK);
    createSearchField(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);
  }
}

package is.codion.demos.chinook.ui;

import is.codion.common.model.condition.ConditionModel;
import is.codion.demos.chinook.domain.api.Chinook.PlaylistTrack;
import is.codion.framework.domain.entity.EntityDefinition;
import is.codion.framework.model.ForeignKeyConditionModel;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityConditionComponentFactory;
import is.codion.swing.framework.ui.EntityEditPanel.Confirmer;
import is.codion.swing.framework.ui.EntityTablePanel;
import is.codion.swing.framework.ui.component.EntitySearchField;

import javax.swing.JComponent;

public final class PlaylistTrackTablePanel extends EntityTablePanel {

  public PlaylistTrackTablePanel(SwingEntityTableModel tableModel) {
    // We provide an edit panel to use when adding a new row. The Add action
    // is available via the popup menu, toolbar and keyboard shortcut (INSERT)
    super(tableModel, new PlaylistTrackEditPanel(tableModel.editModel()), config -> config
            // Custom condition component factory for the track condition panel
            .conditionComponentFactory(PlaylistTrack.TRACK_FK,
                    new TrackConditionComponentFactory(tableModel.entityDefinition()))
            // Skip confirmation when deleting
            .deleteConfirmer(Confirmer.NONE)
            // No need to edit individual rows, we just add or delete
            .includeEditAttributeControl(false)
            .includeEditControl(false));
    // Hide the playlist column
    table().columnModel().visible(PlaylistTrack.PLAYLIST_FK).set(false);
  }

  @Override
  protected void setupControls() {
    // Modify the ADD control so that it is only enabled when a playlist is selected
    control(ControlKeys.ADD).map(control -> control.copy()
            .enabled(tableModel().editModel().editor().value(PlaylistTrack.PLAYLIST_FK).present())
            .build());
  }

  // A ComponentFactory, which uses the TrackSelectorFactory, displaying
  // a table instead of the default list when selecting tracks
  private static final class TrackConditionComponentFactory extends EntityConditionComponentFactory {

    private TrackConditionComponentFactory(EntityDefinition entityDefinition) {
      super(entityDefinition, PlaylistTrack.TRACK_FK);
    }

    @Override
    public <T> JComponent equal(ConditionModel<T> conditionModel) {
      return EntitySearchField.builder(((ForeignKeyConditionModel) conditionModel).equalSearchModel())
              .singleSelection()
              .selectorFactory(new TrackSelectorFactory())
              .build();
    }

    @Override
    public <T> JComponent in(ConditionModel<T> conditionModel) {
      return EntitySearchField.builder(((ForeignKeyConditionModel) conditionModel).inSearchModel())
              .multiSelection()
              .selectorFactory(new TrackSelectorFactory())
              .build();
    }
  }
}

package is.codion.demos.chinook.ui;

import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.EntityDefinition;
import is.codion.framework.domain.entity.attribute.ForeignKey;
import is.codion.framework.model.EntitySearchModel;
import is.codion.swing.framework.ui.component.DefaultEditComponentFactory;
import is.codion.swing.framework.ui.component.EntitySearchField;

/**
 * Provides a {@link EntitySearchField} using the {@link TrackSelectorFactory}.
 */
final class TrackEditComponentFactory extends DefaultEditComponentFactory<Entity, EntitySearchField> {

  TrackEditComponentFactory(ForeignKey trackForeignKey) {
    super(trackForeignKey);
  }

  @Override
  protected EntitySearchField.SingleSelectionBuilder searchField(ForeignKey foreignKey,
                                                                 EntityDefinition entityDefinition,
                                                                 EntitySearchModel searchModel) {
    return (EntitySearchField.SingleSelectionBuilder) super.searchField(foreignKey, entityDefinition, searchModel)
            .selectorFactory(new TrackSelectorFactory());
  }
}

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Track;
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 java.awt.Dimension;
import java.util.function.Function;

import static is.codion.swing.framework.ui.component.EntitySearchField.tableSelector;

/**
 * Provides a {@link TableSelector} for selecting tracks,
 * displaying columns for the artist, album and track name.
 */
final class TrackSelectorFactory implements Function<EntitySearchField, Selector> {

  @Override
  public TableSelector apply(EntitySearchField searchField) {
    TableSelector selector = tableSelector(searchField);
    selector.table().columnModel().visible().set(Track.ARTIST_NAME, Track.ALBUM_FK, Track.NAME);
    selector.table().model().sort().ascending(Track.ARTIST_NAME, Track.ALBUM_FK, Track.NAME);
    selector.preferredSize(new Dimension(500, 300));

    return selector;
  }
}

  interface Preferences {
    EntityType TYPE = DOMAIN.entityType("chinook.preferences", Preferences.class.getName());

    Column<Long> CUSTOMER_ID = TYPE.longColumn("customer_id");
    Column<Long> PREFERRED_GENRE_ID = TYPE.longColumn("preferred_genre_id");
    Column<Boolean> NEWSLETTER_SUBSCRIBED = TYPE.booleanColumn("newsletter_subscribed");

    ForeignKey CUSTOMER_FK = TYPE.foreignKey("customer_fk", CUSTOMER_ID, Customer.ID);
    ForeignKey PREFERRED_GENRE_FK = TYPE.foreignKey("preferred_genre_fk", PREFERRED_GENRE_ID, Genre.ID);
  }

  EntityDefinition preferences() {
    return Preferences.TYPE.define(
                    Preferences.CUSTOMER_ID.define()
                            .primaryKey(),
                    Preferences.CUSTOMER_FK.define()
                            .foreignKey(),
                    Preferences.PREFERRED_GENRE_ID.define()
                            .column(),
                    Preferences.PREFERRED_GENRE_FK.define()
                            .foreignKey()
                            .attributes(Genre.NAME),
                    Preferences.NEWSLETTER_SUBSCRIBED.define()
                            .column()
                            .nullable(false)
                            .defaultValue(false))
            .caption("Preferences")
            .build();
  }

package is.codion.demos.chinook.ui;

import is.codion.demos.chinook.domain.api.Chinook.Preferences;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;

import static is.codion.swing.common.ui.layout.Layouts.flexibleGridLayout;

public final class PreferencesEditPanel extends EntityEditPanel {

  public PreferencesEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    focus().initial().set(Preferences.CUSTOMER_FK);

    createSearchField(Preferences.CUSTOMER_FK)
            .columns(14);
    createComboBox(Preferences.PREFERRED_GENRE_FK)
            .preferredWidth(160);
    createCheckBox(Preferences.NEWSLETTER_SUBSCRIBED);

    setLayout(flexibleGridLayout(3, 1));
    addInputPanel(Preferences.CUSTOMER_FK);
    addInputPanel(Preferences.PREFERRED_GENRE_FK);
    addInputPanel(Preferences.NEWSLETTER_SUBSCRIBED);
  }
}

// extra-java-module-info configuration for core jasper reports library dependencies
plugins {
    id "org.gradlex.extra-java-module-info"
}

extraJavaModuleInfo {
    automaticModule("commons-collections:commons-collections", "commons.collections")
    automaticModule("commons-beanutils:commons-beanutils", "commons.beanutils")
}

// Additional extra-java-module-info configuration for client side jasper reports dependencies,
// including the pdf export module, with a necessary jlink plugin related trick
plugins {
    id("chinook.jasperreports.modules")
}

extraJavaModuleInfo {
    // We transform the jasperreports-pdf automatic module into a full fledged module,
    // otherwise the jlink plugin combines the contents of that jar with the jasperreports
    // core jar in the so-called merged module, overwriting the jasperreports_extension.properties
    // file from the core jar, causing errors that are *incredibly* hard to debug.
    module("net.sf.jasperreports:jasperreports-pdf", "net.sf.jasperreports.pdf") {
        exportAllPackages()
        requires("net.sf.jasperreports.core")
        requires("java.desktop")
        requires("org.apache.commons.logging")
        requires("com.github.librepdf.openpdf")
    }

    knownModule("commons-logging:commons-logging", "org.apache.commons.logging")
    knownModule("com.github.librepdf:openpdf", "com.github.librepdf.openpdf")

    automaticModule("org.eclipse.jdt:ecj", "org.eclipse.jdt.ecj")
    automaticModule("com.adobe.xmp:xmpcore", "com.adobe.xmp.xmpcore")
}

module("net.sf.jasperreports:jasperreports-pdf", "net.sf.jasperreports.pdf") {
    exports("net.sf.jasperreports.export.pdf")
    // ... other exports
}

extraJavaModuleInfo {
    module("commons-beanutils:commons-beanutils", "org.apache.commons.beanutils") {
        exports("org.apache.commons.beanutils")
        requires("java.sql")
        requires("java.desktop")
        requiresTransitive("org.apache.commons.logging")
    }
}

automaticModule("commons-logging:commons-logging", "org.apache.commons.logging")

module("old-library:old-library", "old.library") {
    exportAllPackages()
    requireAllDefinedDependencies()
}

module("javafx-library:javafx-library", "javafx.library") {
    requires("javafx.controls")
    requires("javafx.fxml")
    exports("com.library.javafx")
}

module("broken:library", "broken.library") {
    patchRealModule()  // Overwrite existing module-info.class
    requires("missing.dependency")
}