World Tutorial

  interface Country extends Entity {
    EntityType TYPE = DOMAIN.entityType("world.country", Country.class);

    Column<String> CODE = TYPE.stringColumn("code");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> CONTINENT = TYPE.stringColumn("continent");
    Column<String> REGION = TYPE.stringColumn("region");
    Column<Double> SURFACEAREA = TYPE.doubleColumn("surfacearea");
    Column<Integer> INDEPYEAR = TYPE.integerColumn("indepyear");
    Column<String> INDEPYEAR_SEARCHABLE = TYPE.stringColumn("indepyear_searchable");
    Column<Integer> POPULATION = TYPE.integerColumn("population");
    Column<Double> LIFE_EXPECTANCY = TYPE.doubleColumn("lifeexpectancy");
    Column<Double> GNP = TYPE.doubleColumn("gnp");
    Column<Double> GNPOLD = TYPE.doubleColumn("gnpold");
    Column<String> LOCALNAME = TYPE.stringColumn("localname");
    Column<String> GOVERNMENTFORM = TYPE.stringColumn("governmentform");
    Column<String> HEADOFSTATE = TYPE.stringColumn("headofstate");
    Column<Integer> CAPITAL = TYPE.integerColumn("capital");
    Column<String> CODE_2 = TYPE.stringColumn("code2");
    Attribute<Integer> CAPITAL_POPULATION = TYPE.integerAttribute("capital_population");
    Column<Integer> NO_OF_CITIES = TYPE.integerColumn("no_of_cities");
    Column<Integer> NO_OF_LANGUAGES = TYPE.integerColumn("no_of_languages");
    Column<byte[]> FLAG = TYPE.byteArrayColumn("flag");

    ForeignKey CAPITAL_FK = TYPE.foreignKey("capital_fk", CAPITAL, City.ID);

    FunctionType<EntityConnection, String, Double> AVERAGE_CITY_POPULATION = functionType("average_city_population");

    String name();
    String continent();
    String region();
    double surfacearea();
    int population();
  }

  void country() {
    add(Country.TYPE.define(
            Country.CODE.define()
                    .primaryKey()
                    .caption("Country code")
                    .updatable(true)
                    .maximumLength(3),
            Country.NAME.define()
                    .column()
                    .caption("Name")
                    .searchable(true)
                    .nullable(false)
                    .maximumLength(52),
            Country.CONTINENT.define()
                    .column()
                    .caption("Continent")
                    .items(CONTINENT_ITEMS)
                    .nullable(false),
            Country.REGION.define()
                    .column()
                    .caption("Region")
                    .nullable(false)
                    .maximumLength(26),
            Country.SURFACEAREA.define()
                    .column()
                    .caption("Surface area")
                    .nullable(false)
                    .numberFormatGrouping(true)
                    .maximumFractionDigits(2),
            Country.INDEPYEAR.define()
                    .column()
                    .caption("Indep. year")
                    .valueRange(-2000, 2500),
            Country.INDEPYEAR_SEARCHABLE.define()
                    .column()
                    .expression("to_char(indepyear)")
                    .searchable(true)
                    .readOnly(true),
            Country.POPULATION.define()
                    .column()
                    .caption("Population")
                    .nullable(false)
                    .numberFormatGrouping(true),
            Country.LIFE_EXPECTANCY.define()
                    .column()
                    .caption("Life expectancy")
                    .maximumFractionDigits(1)
                    .valueRange(0, 99),
            Country.GNP.define()
                    .column()
                    .caption("GNP")
                    .numberFormatGrouping(true)
                    .maximumFractionDigits(2),
            Country.GNPOLD.define()
                    .column()
                    .caption("GNP old")
                    .numberFormatGrouping(true)
                    .maximumFractionDigits(2),
            Country.LOCALNAME.define()
                    .column()
                    .caption("Local name")
                    .nullable(false)
                    .maximumLength(45),
            Country.GOVERNMENTFORM.define()
                    .column()
                    .caption("Government form")
                    .nullable(false),
            Country.HEADOFSTATE.define()
                    .column()
                    .caption("Head of state")
                    .maximumLength(60),
            Country.CAPITAL.define()
                    .column(),
            Country.CAPITAL_FK.define()
                    .foreignKey()
                    .caption("Capital"),
            Country.CAPITAL_POPULATION.define()
                    .denormalized(Country.CAPITAL_FK, City.POPULATION)
                    .caption("Capital pop.")
                    .numberFormatGrouping(true),
            Country.NO_OF_CITIES.define()
                    .subquery("""
                            select count(*)
                            from world.city
                            where city.countrycode = country.code""")
                    .caption("No. of cities"),
            Country.NO_OF_LANGUAGES.define()
                    .subquery("""
                            select count(*)
                            from world.countrylanguage
                            where countrylanguage.countrycode = country.code""")
                    .caption("No. of languages"),
            Country.FLAG.define()
                    .column()
                    .caption("Flag")
                    .lazy(true),
            Country.CODE_2.define()
                    .column()
                    .caption("Code2")
                    .nullable(false)
                    .maximumLength(2))
            .orderBy(ascending(Country.NAME))
            .stringFactory(Country.NAME)
            .caption("Country"));

    add(Country.AVERAGE_CITY_POPULATION, new AverageCityPopulationFunction());
  }

  private static final class AverageCityPopulationFunction implements DatabaseFunction<EntityConnection, String, Double> {

    @Override
    public Double execute(EntityConnection connection, String countryCode) throws DatabaseException {
      return connection.select(City.POPULATION,
                      City.COUNTRY_CODE.equalTo(countryCode))
              .stream()
              .mapToInt(Integer::intValue)
              .average()
              .orElse(0d);
    }
  }

package is.codion.framework.demos.world.model;

import is.codion.framework.db.EntityConnectionProvider;
import is.codion.swing.framework.model.SwingEntityModel;

public final class CountryModel extends SwingEntityModel {

  CountryModel(EntityConnectionProvider connectionProvider) {
    super(new CountryTableModel(connectionProvider));
    SwingEntityModel cityModel = new SwingEntityModel(new CityTableModel(connectionProvider));
    SwingEntityModel countryLanguageModel = new SwingEntityModel(new CountryLanguageTableModel(connectionProvider));
    addDetailModels(cityModel, countryLanguageModel);
  }
}

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.common.value.Value;
import is.codion.common.value.ValueObserver;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.ForeignKey;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.model.component.EntityComboBoxModel;

public final class CountryEditModel extends SwingEntityEditModel {

  private final Value<Double> averageCityPopulation = Value.value();

  CountryEditModel(EntityConnectionProvider connectionProvider) {
    super(Country.TYPE, connectionProvider);
    initializeComboBoxModels(Country.CAPITAL_FK);
    addEntityListener(country -> averageCityPopulation.set(averageCityPopulation(country)));
  }

  @Override
  public EntityComboBoxModel createForeignKeyComboBoxModel(ForeignKey foreignKey) {
    EntityComboBoxModel comboBoxModel = super.createForeignKeyComboBoxModel(foreignKey);
    if (foreignKey.equals(Country.CAPITAL_FK)) {
      //only show cities for currently selected country
      addEntityListener(country ->
              comboBoxModel.includeCondition().set(cityEntity ->
                      cityEntity.castTo(City.class)
                              .isInCountry(country)));
    }

    return comboBoxModel;
  }

  public ValueObserver<Double> averageCityPopulation() {
    return averageCityPopulation.observer();
  }

  private Double averageCityPopulation(Entity country) {
    if (country == null) {
      return null;
    }
    try {
      return connectionProvider().connection().execute(Country.AVERAGE_CITY_POPULATION, country.get(Country.CODE));
    }
    catch (DatabaseException e) {
      throw new RuntimeException(e);
    }
  }
}

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.common.db.report.ReportException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.domain.entity.condition.Condition;
import is.codion.framework.model.EntitySearchConditionModel;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;
import is.codion.swing.framework.model.SwingEntityTableModel;

import net.sf.jasperreports.engine.JasperPrint;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

import static is.codion.plugin.jasperreports.JasperReports.classPathReport;
import static is.codion.plugin.jasperreports.JasperReports.fillReport;
import static java.util.Collections.singletonMap;

public final class CountryTableModel extends SwingEntityTableModel {

  private static final String CITY_SUBREPORT_PARAMETER = "CITY_SUBREPORT";
  private static final String COUNTRY_REPORT = "country_report.jasper";
  private static final String CITY_REPORT = "city_report.jasper";

  CountryTableModel(EntityConnectionProvider connectionProvider) {
    super(new CountryEditModel(connectionProvider));
    configureCapitalConditionModel();
  }

  public JasperPrint fillCountryReport(ProgressReporter<String> progressReporter) throws ReportException {
    CountryReportDataSource dataSource = new CountryReportDataSource(selectionModel().getSelectedItems(),
            connectionProvider().connection(), progressReporter);

    return fillReport(classPathReport(CountryTableModel.class, COUNTRY_REPORT), dataSource, reportParameters());
  }

  private static Map<String, Object> reportParameters() throws ReportException {
    return new HashMap<>(singletonMap(CITY_SUBREPORT_PARAMETER,
            classPathReport(CityTableModel.class, CITY_REPORT).load()));
  }

  private void configureCapitalConditionModel() {
    ((EntitySearchConditionModel) conditionModel()
            .attributeModel(Country.CAPITAL_FK))
            .searchModel()
            .condition()
            .set(new CapitalConditionSupplier());
  }

  private final class CapitalConditionSupplier implements Supplier<Condition> {
    @Override
    public Condition get() {
      EntityConnection connection = connectionProvider().connection();
      try {
        return City.ID.in(connection.select(Country.CAPITAL));
      }
      catch (DatabaseException e) {
        throw new RuntimeException(e);
      }
    }
  }
}

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.domain.entity.Entity;
import is.codion.plugin.jasperreports.JasperReportsDataSource;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;

import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRField;

import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Consumer;

import static is.codion.framework.db.EntityConnection.Select.where;
import static is.codion.framework.domain.entity.OrderBy.descending;

public final class CountryReportDataSource extends JasperReportsDataSource<Country> {

  private final EntityConnection connection;

  CountryReportDataSource(List<Entity> countries, EntityConnection connection,
                          ProgressReporter<String> progressReporter) {
    super(Entity.castTo(Country.class, countries).iterator(), new CountryValueProvider(),
            new CountryReportProgressReporter(progressReporter));
    this.connection = connection;
  }

  /* See usage in src/main/reports/country_report.jrxml, subreport element */
  public JRDataSource cityDataSource() {
    Country country = currentItem();
    try {
      Collection<City> largestCities = Entity.castTo(City.class,
              connection.select(where(City.COUNTRY_FK.equalTo(country))
                      .attributes(City.NAME, City.POPULATION)
                      .orderBy(descending(City.POPULATION))
                      .limit(5)
                      .build()));

      return new JasperReportsDataSource<>(largestCities.iterator(), new CityValueProvider());
    }
    catch (DatabaseException e) {
      throw new RuntimeException(e);
    }
  }

  private static final class CountryValueProvider implements BiFunction<Country, JRField, Object> {

    private static final String NAME = "name";
    private static final String CONTINENT = "continent";
    private static final String REGION = "region";
    private static final String SURFACEAREA = "surfacearea";
    private static final String POPULATION = "population";

    @Override
    public Object apply(Country country, JRField field) {
      return switch (field.getName()) {
        case NAME -> country.name();
        case CONTINENT -> country.continent();
        case REGION -> country.region();
        case SURFACEAREA -> country.surfacearea();
        case POPULATION -> country.population();
        default -> throw new IllegalArgumentException("Unknown field: " + field.getName());
      };
    }
  }

  private static final class CityValueProvider implements BiFunction<City, JRField, Object> {

    private static final String NAME = "name";
    private static final String POPULATION = "population";

    @Override
    public Object apply(City city, JRField field) {
      return switch (field.getName()) {
        case NAME -> city.name();
        case POPULATION -> city.population();
        default -> throw new IllegalArgumentException("Unknown field: " + field.getName());
      };
    }
  }

  private static final class CountryReportProgressReporter implements Consumer<Country> {

    private final AtomicInteger counter = new AtomicInteger();
    private final ProgressReporter<String> progressReporter;

    private CountryReportProgressReporter(ProgressReporter<String> progressReporter) {
      this.progressReporter = progressReporter;
    }

    @Override
    public void accept(Country country) {
      progressReporter.publish(country.name());
      progressReporter.report(counter.incrementAndGet());
    }
  }
}

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.common.user.User;
import is.codion.common.value.Value;
import is.codion.framework.db.EntityConnection;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.db.local.LocalEntityConnectionProvider;
import is.codion.framework.demos.world.domain.WorldImpl;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.attribute.Attribute;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;

import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRField;
import net.sf.jasperreports.engine.base.JRBaseField;
import org.junit.jupiter.api.Test;

import java.util.List;

import static is.codion.framework.db.EntityConnection.Select.where;
import static is.codion.framework.domain.entity.OrderBy.ascending;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

public final class CountryReportDataSourceTest {

  private static final User UNIT_TEST_USER =
          User.parse(System.getProperty("codion.test.user", "scott:tiger"));

  @Test
  void iterate() throws DatabaseException, JRException {
    try (EntityConnectionProvider connectionProvider = createConnectionProvider()) {
      Value<Integer> progressCounter = Value.value();
      Value<String> publishedValue = Value.value();
      ProgressReporter<String> progressReporter = new ProgressReporter<>() {
        @Override
        public void report(int progress) {
          progressCounter.set(progress);
        }

        @Override
        public void publish(String... chunks) {
          publishedValue.set(chunks[0]);
        }
      };

      EntityConnection connection = connectionProvider.connection();
      List<Entity> countries =
              connection.select(where(Country.NAME.in("Denmark", "Iceland"))
              .orderBy(ascending(Country.NAME))
              .build());
      CountryReportDataSource countryReportDataSource = new CountryReportDataSource(countries, connection, progressReporter);
      assertThrows(IllegalStateException.class, countryReportDataSource::cityDataSource);

      countryReportDataSource.next();
      assertEquals("Denmark", countryReportDataSource.getFieldValue(field(Country.NAME)));
      assertEquals("Europe", countryReportDataSource.getFieldValue(field(Country.CONTINENT)));
      assertEquals("Nordic Countries", countryReportDataSource.getFieldValue(field(Country.REGION)));
      assertEquals(43094d, countryReportDataSource.getFieldValue(field(Country.SURFACEAREA)));
      assertEquals(5330000, countryReportDataSource.getFieldValue(field(Country.POPULATION)));
      assertThrows(IllegalArgumentException.class, () -> countryReportDataSource.getFieldValue(field(City.LOCATION)));

      JRDataSource denmarkCityDataSource = countryReportDataSource.cityDataSource();
      denmarkCityDataSource.next();
      assertEquals("K\u00F8benhavn", denmarkCityDataSource.getFieldValue(field(City.NAME)));
      assertEquals(495699, denmarkCityDataSource.getFieldValue(field(City.POPULATION)));
      assertThrows(IllegalArgumentException.class, () -> denmarkCityDataSource.getFieldValue(field(Country.REGION)));
      denmarkCityDataSource.next();
      assertEquals("\u00C5rhus", denmarkCityDataSource.getFieldValue(field(City.NAME)));

      countryReportDataSource.next();
      assertEquals("Iceland", countryReportDataSource.getFieldValue(field(Country.NAME)));

      JRDataSource icelandCityDataSource = countryReportDataSource.cityDataSource();
      icelandCityDataSource.next();
      assertEquals("Reykjav\u00EDk", icelandCityDataSource.getFieldValue(field(City.NAME)));

      assertEquals(2, progressCounter.get());
      assertEquals("Iceland", publishedValue.get());
    }
  }

  private static EntityConnectionProvider createConnectionProvider() {
    return LocalEntityConnectionProvider.builder()
            .domain(new WorldImpl())
            .user(UNIT_TEST_USER)
            .build();
  }

  private static JRField field(Attribute<?> attribute) {
    return new TestField(attribute.name());
  }

  private static final class TestField extends JRBaseField {

    private TestField(String name) {
      this.name = name;
    }
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.CountryLanguage;
import is.codion.framework.demos.world.model.CountryModel;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;

import static is.codion.swing.framework.ui.TabbedPanelLayout.splitPaneResizeWeight;

final class CountryPanel extends EntityPanel {

  CountryPanel(CountryModel countryModel) {
    super(countryModel,
            new CountryEditPanel(countryModel.editModel()),
            new CountryTablePanel(countryModel.tableModel()),
            splitPaneResizeWeight(0.7));

    SwingEntityModel cityModel = countryModel.detailModel(City.TYPE);
    EntityPanel cityPanel = new EntityPanel(cityModel,
            new CityEditPanel(cityModel.tableModel()),
            new CityTablePanel(cityModel.tableModel()));

    SwingEntityModel countryLanguageModel = countryModel.detailModel(CountryLanguage.TYPE);
    EntityPanel countryLanguagePanel = new EntityPanel(countryLanguageModel,
            new CountryLanguageEditPanel(countryLanguageModel.editModel()),
            new CountryLanguageTablePanel(countryLanguageModel.tableModel()));

    addDetailPanels(cityPanel, countryLanguagePanel);
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.demos.world.model.CountryEditModel;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.component.text.NumberField;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;

import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.SwingConstants;

import static is.codion.swing.common.ui.component.Components.*;
import static is.codion.swing.common.ui.layout.Layouts.gridLayout;

final class CountryEditPanel extends EntityEditPanel {

  private static final int PREFERRED_COMBO_BOX_WIDTH = 120;

  CountryEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    initialFocusAttribute().set(Country.CODE);

    createTextField(Country.CODE)
            .columns(6)
            .upperCase(true);
    createTextField(Country.CODE_2)
            .columns(6)
            .upperCase(true);
    createTextField(Country.NAME);
    createTextField(Country.LOCALNAME);
    createItemComboBox(Country.CONTINENT)
            .preferredWidth(PREFERRED_COMBO_BOX_WIDTH);
    createComboBox(Country.REGION)
            .preferredWidth(PREFERRED_COMBO_BOX_WIDTH);
    createTextField(Country.SURFACEAREA)
            .columns(5);
    createTextField(Country.INDEPYEAR)
            .columns(5);
    createTextField(Country.POPULATION)
            .columns(5);
    createTextField(Country.LIFE_EXPECTANCY)
            .columns(5);
    createTextField(Country.GNP)
            .columns(6);
    createTextField(Country.GNPOLD)
            .columns(6);
    createComboBox(Country.GOVERNMENTFORM)
            .preferredWidth(PREFERRED_COMBO_BOX_WIDTH)
            .editable(true);
    createTextField(Country.HEADOFSTATE);
    //create a panel with a button for adding a new city
    createForeignKeyComboBoxPanel(Country.CAPITAL_FK, this::createCapitalEditPanel)
            .add(true);
    //add a field displaying the avarage city population for the selected country
    CountryEditModel editModel = editModel();
    NumberField<Double> averageCityPopulationField = doubleField()
            .linkedValue(editModel.averageCityPopulation())
            .maximumFractionDigits(2)
            .groupingUsed(true)
            .horizontalAlignment(SwingConstants.CENTER)
            .focusable(false)
            .editable(false)
            .build();

    JPanel codePanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Country.CODE))
            .add(createInputPanel(Country.CODE_2))
            .build();

    JPanel gnpPanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Country.GNP))
            .add(createInputPanel(Country.GNPOLD))
            .build();

    JPanel surfaceAreaIndYearPanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Country.SURFACEAREA))
            .add(createInputPanel(Country.INDEPYEAR))
            .build();

    JPanel populationLifeExpectancyPanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(Country.POPULATION))
            .add(createInputPanel(Country.LIFE_EXPECTANCY))
            .build();

    setLayout(gridLayout(4, 5));

    add(codePanel);
    addInputPanel(Country.NAME);
    addInputPanel(Country.LOCALNAME);
    addInputPanel(Country.CAPITAL_FK);
    addInputPanel(Country.CONTINENT);
    addInputPanel(Country.REGION);
    add(surfaceAreaIndYearPanel);
    add(populationLifeExpectancyPanel);
    add(gnpPanel);
    addInputPanel(Country.GOVERNMENTFORM);
    addInputPanel(Country.HEADOFSTATE);
    add(createInputPanel(label("Avg. city population")
            .horizontalAlignment(SwingConstants.CENTER)
            .build(), averageCityPopulationField));
  }

  private EntityEditPanel createCapitalEditPanel() {
    CityEditPanel capitalEditPanel = new CityEditPanel(new SwingEntityEditModel(City.TYPE, editModel().connectionProvider()));
    Entity country = editModel().entity();
    if (country.primaryKey().isNotNull()) {
      //if a country is selected, then we don't allow it to be changed
      capitalEditPanel.editModel().put(City.COUNTRY_FK, country);
      //initialize the panel components, so we can configure the country component
      capitalEditPanel.initialize();
      //disable the country selection component
      JComponent countryComponent = capitalEditPanel.component(City.COUNTRY_FK).get();
      countryComponent.setEnabled(false);
      countryComponent.setFocusable(false);
      //and change the initial focus property
      capitalEditPanel.initialFocusAttribute().set(City.NAME);
    }

    return capitalEditPanel;
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.common.db.report.ReportException;
import is.codion.framework.demos.world.domain.api.World;
import is.codion.framework.demos.world.model.CountryTableModel;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;
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;

final class CountryTablePanel extends EntityTablePanel {

  CountryTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel);
    configure().editableAttributes().remove(World.Country.CAPITAL_FK);
  }

  @Override
  protected void setupControls() {
    control(TableControl.PRINT).set(Control.builder(this::viewCountryReport)
            .name("Country report")
            .enabled(tableModel().selectionModel().selectionNotEmpty())
            .smallIcon(FrameworkIcons.instance().print())
            .build());
  }

  private void viewCountryReport() {
    Dialogs.progressWorkerDialog(this::fillCountryReport)
            .owner(this)
            .maximumProgress(tableModel().selectionModel().selectionCount())
            .stringPainted(true)
            .onResult(this::viewReport)
            .execute();
  }

  private JasperPrint fillCountryReport(ProgressReporter<String> progressReporter) throws ReportException {
    CountryTableModel countryTableModel = tableModel();

    return countryTableModel.fillCountryReport(progressReporter);
  }

  private void viewReport(JasperPrint countryReport) {
    Dialogs.componentDialog(new JRViewer(countryReport))
            .owner(this)
            .modal(false)
            .title("Country report")
            .size(new Dimension(800, 600))
            .show();
  }
}

  interface City extends Entity {
    EntityType TYPE = DOMAIN.entityType("world.city", City.class);

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> COUNTRY_CODE = TYPE.stringColumn("countrycode");
    Column<String> DISTRICT = TYPE.stringColumn("district");
    Column<Integer> POPULATION = TYPE.integerColumn("population");
    Column<Location> LOCATION = TYPE.column("location", Location.class);

    ForeignKey COUNTRY_FK = TYPE.foreignKey("country", COUNTRY_CODE, Country.CODE);

    String name();
    int population();
    Country country();
    void location(Location location);

    default boolean isInCountry(Entity country) {
      return country != null && Objects.equals(country(), country);
    }

    default boolean isCapital() {
      return Objects.equals(get(City.ID), country().get(Country.CAPITAL));
    }
  }

  record Location(double latitude, double longitude) implements Serializable {

    @Override
    public String toString() {
      return "[" + latitude + "," + longitude + "]";
    }
  }

  final class LocationComparator implements Comparator<Location>, Serializable {

    @Override
    public int compare(Location l1, Location l2) {
      int result = Double.compare(l1.latitude(), l2.latitude());
      if (result == 0) {
        return Double.compare(l1.longitude(), l2.longitude());
      }

      return result;
    }
  }

  final class CityValidator extends DefaultEntityValidator implements Serializable {

    @Serial
    private static final long serialVersionUID = 1;

    @Override
    public void validate(Entity city) throws ValidationException {
      super.validate(city);
      //after a call to super.validate() values that are not nullable
      //(such as country and population) are guaranteed to be non-null
      Entity country = city.get(City.COUNTRY_FK);
      Integer cityPopulation = city.get(City.POPULATION);
      Integer countryPopulation = country.get(Country.POPULATION);
      if (countryPopulation != null && cityPopulation > countryPopulation) {
        throw new ValidationException(City.POPULATION,
                cityPopulation, "City population can not exceed country population");
      }
    }
  }

  final class CityColorProvider implements ColorProvider {

    @Serial
    private static final long serialVersionUID = 1;

    private static final String YELLOW = "#ffff00";
    private static final String GREEN = "#00ff00";

    @Override
    public Object color(Entity cityEntity, Attribute<?> attribute) {
      if (attribute.equals(City.POPULATION) &&
              cityEntity.get(City.POPULATION) > 1_000_000) {
        return YELLOW;
      }
      City city = cityEntity.castTo(City.class);
      if (attribute.equals(City.NAME) && city.isCapital()) {
        return GREEN;
      }

      return null;
    }
  }

  void city() {
    add(City.TYPE.define(
            City.ID.define()
                    .primaryKey(),
            City.NAME.define()
                    .column()
                    .caption("Name")
                    .searchable(true)
                    .nullable(false)
                    .maximumLength(35),
            City.COUNTRY_CODE.define()
                    .column()
                    .nullable(false),
            City.COUNTRY_FK.define()
                    .foreignKey()
                    .caption("Country"),
            City.DISTRICT.define()
                    .column()
                    .caption("District")
                    .nullable(false)
                    .maximumLength(20),
            City.POPULATION.define()
                    .column()
                    .caption("Population")
                    .nullable(false)
                    .numberFormatGrouping(true),
            City.LOCATION.define()
                    .column()
                    .caption("Location")
                    .columnClass(String.class, new LocationConverter())
                    .comparator(new LocationComparator()))
            .keyGenerator(sequence("world.city_seq"))
            .validator(new CityValidator())
            .orderBy(ascending(City.NAME))
            .stringFactory(City.NAME)
            .foregroundColorProvider(new CityColorProvider())
            .caption("City"));
  }

  private static final class LocationConverter implements Converter<Location, String> {

    @Override
    public String toColumnValue(Location location,
                                Statement statement) {
      if (location == null) {
        return null;
      }

      return "POINT (" + location.longitude() + " " + location.latitude() + ")";
    }

    @Override
    public Location fromColumnValue(String columnValue) {
      if (columnValue == null) {
        return null;
      }

      String[] latLon = columnValue
              .replace("POINT (", "")
              .replace(")", "")
              .split(" ");

      return new Location(parseDouble(latLon[1]), parseDouble(latLon[0]));
    }
  }

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.domain.api.World.Location;
import is.codion.framework.domain.entity.exception.ValidationException;
import is.codion.swing.framework.model.SwingEntityEditModel;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Optional;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Collections.singletonList;
import static java.util.stream.Collectors.joining;

public final class CityEditModel extends SwingEntityEditModel {

  private static final String OPENSTREETMAP_ORG_SEARCH = "https://nominatim.openstreetmap.org/search?q=";

  public CityEditModel(EntityConnectionProvider connectionProvider) {
    super(City.TYPE, connectionProvider);
    initializeComboBoxModels(City.COUNTRY_FK);
  }

  public void populateLocation() throws IOException, DatabaseException, ValidationException {
    Location location = lookupLocation(entity().castTo(City.class))
            .orElseThrow(() -> new RuntimeException("Location not found for city: " + entity()));
    put(City.LOCATION, location);
    if (modified().get()) {
      update();
    }
  }

  void populateLocation(City city) throws IOException, DatabaseException, ValidationException {
    lookupLocation(city).ifPresent(city::location);
    if (city.modified()) {
      update(singletonList(city));
    }
  }

  private static Optional<Location> lookupLocation(City city) throws IOException {
    JSONArray jsonArray = toJSONArray(new URL(OPENSTREETMAP_ORG_SEARCH +
            URLEncoder.encode(city.name(), UTF_8) + "," +
            URLEncoder.encode(city.country().name(), UTF_8) + "&format=json"));
    if (!jsonArray.isEmpty()) {
      JSONObject cityInformation = (JSONObject) jsonArray.get(0);

      return Optional.of(new Location(cityInformation.getDouble("lat"), cityInformation.getDouble("lon")));
    }

    return Optional.empty();
  }

  private static JSONArray toJSONArray(URL url) throws IOException {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openConnection().getInputStream(), UTF_8))) {
      return new JSONArray(reader.lines().collect(joining()));
    }
  }
}

package is.codion.framework.demos.world.model;

import is.codion.common.db.exception.DatabaseException;
import is.codion.common.event.Event;
import is.codion.common.state.State;
import is.codion.common.state.StateObserver;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.exception.ValidationException;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;
import is.codion.swing.framework.model.SwingEntityTableModel;

import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;

import static java.util.Collections.singletonList;

public final class CityTableModel extends SwingEntityTableModel {

  private final DefaultPieDataset<String> chartDataset = new DefaultPieDataset<>();
  private final Event<Collection<Entity>> displayLocationEvent = Event.event();
  private final State citiesWithoutLocationSelected = State.state();

  CityTableModel(EntityConnectionProvider connectionProvider) {
    super(new CityEditModel(connectionProvider));
    selectionModel().addSelectedItemsListener(displayLocationEvent::accept);
    selectionModel().addSelectionListener(this::updateCitiesWithoutLocationSelected);
    refresher().addRefreshListener(this::refreshChartDataset);
  }

  public PieDataset<String> chartDataset() {
    return chartDataset;
  }

  public void addDisplayLocationListener(Consumer<Collection<Entity>> listener) {
    displayLocationEvent.addDataListener(listener);
  }

  public StateObserver citiesWithoutLocationSelected() {
    return citiesWithoutLocationSelected.observer();
  }

  public void populateLocationForSelected(ProgressReporter<String> progressReporter,
                                          StateObserver cancelPopulateLocation)
          throws IOException, DatabaseException, ValidationException {
    Collection<Entity> updatedCities = new ArrayList<>();
    Collection<City> selectedCitiesWithoutLocation = selectionModel().getSelectedItems().stream()
            .filter(city -> city.isNull(City.LOCATION))
            .map(city -> city.castTo(City.class))
            .toList();
    CityEditModel editModel = editModel();
    Iterator<City> citiesWithoutLocation = selectedCitiesWithoutLocation.iterator();
    while (citiesWithoutLocation.hasNext() && !cancelPopulateLocation.get()) {
      City city = citiesWithoutLocation.next();
      progressReporter.publish(city.country().name() + " - " + city.name());
      editModel.populateLocation(city);
      updatedCities.add(city);
      progressReporter.report(100 * updatedCities.size() / selectedCitiesWithoutLocation.size());
      displayLocationEvent.accept(singletonList(city));
    }
    displayLocationEvent.accept(selectionModel().getSelectedItems());
  }

  private void refreshChartDataset() {
    chartDataset.clear();
    Entity.castTo(City.class, visibleItems()).forEach(city ->
            chartDataset.setValue(city.name(), city.population()));
  }

  private void updateCitiesWithoutLocationSelected() {
    citiesWithoutLocationSelected.set(selectionModel().getSelectedItems().stream()
            .anyMatch(city -> city.isNull(City.LOCATION)));
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.common.db.exception.DatabaseException;
import is.codion.common.state.State;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.model.CityEditModel;
import is.codion.framework.demos.world.model.CityTableModel;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.domain.entity.exception.ValidationException;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;
import is.codion.swing.framework.ui.icon.FrameworkIcons;

import org.jxmapviewer.JXMapKit;
import org.kordamp.ikonli.foundation.Foundation;

import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.io.IOException;
import java.util.Collection;

import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.util.Collections.singleton;
import static java.util.stream.Collectors.toSet;

public final class CityEditPanel extends EntityEditPanel {

  private final JXMapKit mapKit;

  public CityEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
    this.mapKit = null;
  }

  CityEditPanel(CityTableModel tableModel) {
    super(tableModel.editModel());
    this.mapKit = Maps.createMapKit();
    tableModel.addDisplayLocationListener(this::displayLocation);
  }

  @Override
  protected void initializeUI() {
    initialFocusAttribute().set(City.COUNTRY_FK);

    createForeignKeyComboBox(City.COUNTRY_FK)
            .preferredWidth(120);
    createTextField(City.NAME);
    createTextField(City.DISTRICT);
    createTextField(City.POPULATION);

    JPanel inputPanel = gridLayoutPanel(0, 1)
            .add(createInputPanel(City.COUNTRY_FK))
            .add(createInputPanel(City.NAME))
            .add(createInputPanel(City.DISTRICT))
            .add(createInputPanel(City.POPULATION))
            .build();

    JPanel centerPanel = gridLayoutPanel(1, 0)
            .add(inputPanel)
            .build();
    if (mapKit != null) {
      centerPanel.add(mapKit);
    }
    setLayout(borderLayout());
    add(centerPanel, BorderLayout.CENTER);
  }

  @Override
  protected Controls createControls() {
    return super.createControls()
            .addAt(4, Control.builder(this::populateLocation)
                    .enabled(State.and(active(),
                            editModel().isNull(City.LOCATION),
                            editModel().exists()))
                    .smallIcon(FrameworkIcons.instance().icon(Foundation.MAP))
                    .build());
  }

  private void populateLocation() throws ValidationException, IOException, DatabaseException {
    CityEditModel editModel = editModel();
    editModel.populateLocation();
    displayLocation(singleton(editModel.entity()));
  }

  private void displayLocation(Collection<Entity> cities) {
    Maps.paintWaypoints(cities.stream()
            .filter(city -> city.isNotNull(City.LOCATION))
            .map(city -> city.get(City.LOCATION))
            .collect(toSet()), mapKit.getMainMap());
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.common.state.State;
import is.codion.common.state.StateObserver;
import is.codion.framework.demos.world.domain.api.World.City;
import is.codion.framework.demos.world.model.CityTableModel;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressReporter;
import is.codion.swing.common.model.worker.ProgressWorker.ProgressTask;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.dialog.Dialogs;
import is.codion.swing.framework.ui.icon.FrameworkIcons;

import org.kordamp.ikonli.foundation.Foundation;

import java.util.List;

final class CityTablePanel extends ChartTablePanel {

  CityTablePanel(CityTableModel tableModel) {
    super(tableModel, tableModel.chartDataset(), "Cities");
    configure().editableAttributes().remove(City.LOCATION);
  }

  @Override
  protected Controls createPopupMenuControls(List<Controls> additionalPopupMenuControls) {
    return super.createPopupMenuControls(additionalPopupMenuControls)
            .addAt(0, createPopulateLocationControl())
            .addSeparatorAt(1);
  }

  private Control createPopulateLocationControl() {
    CityTableModel cityTableModel = tableModel();

    return Control.builder(this::populateLocation)
            .name("Populate location")
            .enabled(cityTableModel.citiesWithoutLocationSelected())
            .smallIcon(FrameworkIcons.instance().icon(Foundation.MAP))
            .build();
  }

  private void populateLocation() {
    PopulateLocationTask populateLocationTask = new PopulateLocationTask(tableModel());

    Dialogs.progressWorkerDialog(populateLocationTask)
            .owner(this)
            .title("Populating locations")
            .stringPainted(true)
            .controls(Controls.builder()
                    .control(Control.builder(populateLocationTask::cancel)
                            .name("Cancel")
                            .enabled(populateLocationTask.isWorking()))
                    .build())
            .onException(this::displayPopulateException)
            .execute();
  }

  private void displayPopulateException(Throwable exception) {
    Dialogs.exceptionDialog()
            .owner(this)
            .title("Unable to populate location")
            .show(exception);
  }

  private static final class PopulateLocationTask implements ProgressTask<Void, String> {

    private final CityTableModel tableModel;
    private final State cancelled = State.state();

    private PopulateLocationTask(CityTableModel tableModel) {
      this.tableModel = tableModel;
    }

    @Override
    public Void execute(ProgressReporter<String> progressReporter) throws Exception {
      tableModel.populateLocationForSelected(progressReporter, cancelled);
      return null;
    }

    private void cancel() {
      cancelled.set(true);
    }

    private StateObserver isWorking() {
      return cancelled.not();
    }
  }
}

  interface CountryLanguage extends Entity {
    EntityType TYPE = DOMAIN.entityType("world.countrylanguage", CountryLanguage.class);

    Column<String> COUNTRY_CODE = TYPE.stringColumn("countrycode");
    Column<String> LANGUAGE = TYPE.stringColumn("language");
    Column<Boolean> IS_OFFICIAL = TYPE.booleanColumn("isofficial");
    Column<Double> PERCENTAGE = TYPE.doubleColumn("percentage");
    Attribute<Integer> NO_OF_SPEAKERS = TYPE.integerAttribute("noOfSpeakers");

    ForeignKey COUNTRY_FK = TYPE.foreignKey("country_fk", COUNTRY_CODE, Country.CODE);

    String language();
    int noOfSpeakers();
  }

  final class NoOfSpeakersProvider implements DerivedAttribute.Provider<Integer> {

    @Serial
    private static final long serialVersionUID = 1;

    @Override
    public Integer get(SourceValues sourceValues) {
      Double percentage = sourceValues.get(CountryLanguage.PERCENTAGE);
      Entity country = sourceValues.get(CountryLanguage.COUNTRY_FK);
      if (notNull(percentage, country) && country.isNotNull(Country.POPULATION)) {
        return Double.valueOf(country.get(Country.POPULATION) * (percentage / 100)).intValue();
      }

      return null;
    }
  }

  void countryLanguage() {
    add(CountryLanguage.TYPE.define(
            CountryLanguage.COUNTRY_CODE.define()
                    .primaryKey(0)
                    .updatable(true),
            CountryLanguage.LANGUAGE.define()
                    .primaryKey(1)
                    .caption("Language")
                    .updatable(true),
            CountryLanguage.COUNTRY_FK.define()
                    .foreignKey()
                    .caption("Country"),
            CountryLanguage.IS_OFFICIAL.define()
                    .column()
                    .caption("Is official")
                    .columnHasDefaultValue(true)
                    .nullable(false),
            CountryLanguage.NO_OF_SPEAKERS.define()
                    .derived(new NoOfSpeakersProvider(),
                            CountryLanguage.COUNTRY_FK, CountryLanguage.PERCENTAGE)
                    .caption("No. of speakers")
                    .numberFormatGrouping(true),
            CountryLanguage.PERCENTAGE.define()
                    .column()
                    .caption("Percentage")
                    .nullable(false)
                    .maximumFractionDigits(1)
                    .valueRange(0, 100))
            .orderBy(OrderBy.builder()
                    .ascending(CountryLanguage.LANGUAGE)
                    .descending(CountryLanguage.PERCENTAGE)
                    .build())
            .caption("Language"));
  }

package is.codion.framework.demos.world.model;

import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.CountryLanguage;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingEntityTableModel;

import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;

public final class CountryLanguageTableModel extends SwingEntityTableModel {

  private final DefaultPieDataset<String> chartDataset = new DefaultPieDataset<>();

  CountryLanguageTableModel(EntityConnectionProvider connectionProvider) {
    super(CountryLanguage.TYPE, connectionProvider);
    editModel().initializeComboBoxModels(CountryLanguage.COUNTRY_FK);
    refresher().addRefreshListener(this::refreshChartDataset);
  }

  public PieDataset<String> chartDataset() {
    return chartDataset;
  }

  private void refreshChartDataset() {
    chartDataset.clear();
    Entity.castTo(CountryLanguage.class, visibleItems()).forEach(language ->
            chartDataset.setValue(language.language(), language.noOfSpeakers()));
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.framework.demos.world.domain.api.World.CountryLanguage;
import is.codion.swing.framework.model.SwingEntityEditModel;
import is.codion.swing.framework.ui.EntityEditPanel;

import javax.swing.JPanel;

import static is.codion.swing.common.ui.component.Components.gridLayoutPanel;
import static is.codion.swing.common.ui.layout.Layouts.gridLayout;

final class CountryLanguageEditPanel extends EntityEditPanel {

  CountryLanguageEditPanel(SwingEntityEditModel editModel) {
    super(editModel);
  }

  @Override
  protected void initializeUI() {
    initialFocusAttribute().set(CountryLanguage.COUNTRY_FK);

    createForeignKeyComboBox(CountryLanguage.COUNTRY_FK)
            .preferredWidth(120);
    createTextField(CountryLanguage.LANGUAGE);
    createCheckBox(CountryLanguage.IS_OFFICIAL);
    createTextField(CountryLanguage.PERCENTAGE)
            .columns(4);

    JPanel percentageOfficialPanel = gridLayoutPanel(1, 2)
            .add(createInputPanel(CountryLanguage.PERCENTAGE))
            .add(createInputPanel(CountryLanguage.IS_OFFICIAL))
            .build();

    setLayout(gridLayout(0, 1));

    addInputPanel(CountryLanguage.COUNTRY_FK);
    addInputPanel(CountryLanguage.LANGUAGE);
    add(percentageOfficialPanel);
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.framework.demos.world.model.CountryLanguageTableModel;

final class CountryLanguageTablePanel extends ChartTablePanel {

  CountryLanguageTablePanel(CountryLanguageTableModel tableModel) {
    super(tableModel, tableModel.chartDataset(), "Languages");
  }
}

  interface Continent extends Entity {
    EntityType TYPE = DOMAIN.entityType("continent", Continent.class);

    Column<String> NAME = TYPE.stringColumn("continent");
    Column<Integer> SURFACE_AREA = TYPE.integerColumn("surface_area");
    Column<Long> POPULATION = TYPE.longColumn("population");
    Column<Double> MIN_LIFE_EXPECTANCY = TYPE.doubleColumn("min_life_expectancy");
    Column<Double> MAX_LIFE_EXPECTANCY = TYPE.doubleColumn("max_life_expectancy");
    Column<Integer> MIN_INDEPENDENCE_YEAR = TYPE.integerColumn("min_indep_year");
    Column<Integer> MAX_INDEPENDENCE_YEAR = TYPE.integerColumn("max_indep_year");
    Column<Double> GNP = TYPE.doubleColumn("gnp");

    String name();
    int surfaceArea();
    long population();
    double minLifeExpectancy();
    double maxLifeExpectancy();
    double gnp();
  }

  void continent() {
    add(Continent.TYPE.define(
            Continent.NAME.define()
                    .column()
                    .caption("Continent")
                    .groupBy(true)
                    .beanProperty("name"),
            Continent.SURFACE_AREA.define()
                    .column()
                    .caption("Surface area")
                    .expression("sum(surfacearea)")
                    .aggregate(true)
                    .numberFormatGrouping(true),
            Continent.POPULATION.define()
                    .column()
                    .caption("Population")
                    .expression("sum(population)")
                    .aggregate(true)
                    .numberFormatGrouping(true),
            Continent.MIN_LIFE_EXPECTANCY.define()
                    .column()
                    .caption("Min. life expectancy")
                    .expression("min(lifeexpectancy)")
                    .aggregate(true),
            Continent.MAX_LIFE_EXPECTANCY.define()
                    .column()
                    .caption("Max. life expectancy")
                    .expression("max(lifeexpectancy)")
                    .aggregate(true),
            Continent.MIN_INDEPENDENCE_YEAR.define()
                    .column()
                    .caption("Min. ind. year")
                    .expression("min(indepyear)")
                    .aggregate(true),
            Continent.MAX_INDEPENDENCE_YEAR.define()
                    .column()
                    .caption("Max. ind. year")
                    .expression("max(indepyear)")
                    .aggregate(true),
            Continent.GNP.define()
                    .column()
                    .caption("GNP")
                    .expression("sum(gnp)")
                    .aggregate(true)
                    .numberFormatGrouping(true))
            .tableName("world.country")
            .readOnly(true)
            .caption("Continent"));
  }

package is.codion.framework.demos.world.model;

import is.codion.common.model.table.ColumnConditionModel;
import is.codion.common.model.table.ColumnConditionModel.AutomaticWildcard;
import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.Continent;
import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.framework.model.SwingDetailModelLink;
import is.codion.swing.framework.model.SwingEntityModel;

import org.jfree.data.category.CategoryDataset;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;

import java.util.Collection;

public final class ContinentModel extends SwingEntityModel {

  private final DefaultPieDataset<String> surfaceAreaDataset = new DefaultPieDataset<>();
  private final DefaultPieDataset<String> populationDataset = new DefaultPieDataset<>();
  private final DefaultPieDataset<String> gnpDataset = new DefaultPieDataset<>();
  private final DefaultCategoryDataset lifeExpectancyDataset = new DefaultCategoryDataset();

  ContinentModel(EntityConnectionProvider connectionProvider) {
    super(Continent.TYPE, connectionProvider);
    tableModel().refresher().addRefreshListener(this::refreshChartDatasets);
    CountryModel countryModel = new CountryModel(connectionProvider);
    addDetailModel(new CountryModelHandler(countryModel)).active().set(true);
  }

  public PieDataset<String> populationDataset() {
    return populationDataset;
  }

  public PieDataset<String> surfaceAreaDataset() {
    return surfaceAreaDataset;
  }

  public PieDataset<String> gnpDataset() {
    return gnpDataset;
  }

  public CategoryDataset lifeExpectancyDataset() {
    return lifeExpectancyDataset;
  }

  private void refreshChartDatasets() {
    populationDataset.clear();
    surfaceAreaDataset.clear();
    gnpDataset.clear();
    lifeExpectancyDataset.clear();
    Entity.castTo(Continent.class, tableModel().items()).forEach(continent -> {
      populationDataset.setValue(continent.name(), continent.population());
      surfaceAreaDataset.setValue(continent.name(), continent.surfaceArea());
      gnpDataset.setValue(continent.name(), continent.gnp());
      lifeExpectancyDataset.addValue(continent.minLifeExpectancy(), "Lowest", continent.name());
      lifeExpectancyDataset.addValue(continent.maxLifeExpectancy(), "Highest", continent.name());
    });
  }

  private static final class CountryModel extends SwingEntityModel {

    private CountryModel(EntityConnectionProvider connectionProvider) {
      super(Country.TYPE, connectionProvider);
      editModel().readOnly().set(true);
      ColumnConditionModel<?, ?> continentConditionModel =
              tableModel().conditionModel().conditionModel(Country.CONTINENT);
      continentConditionModel.automaticWildcard().set(AutomaticWildcard.NONE);
      continentConditionModel.caseSensitive().set(true);
    }
  }

  private static final class CountryModelHandler extends SwingDetailModelLink {

    private CountryModelHandler(SwingEntityModel detailModel) {
      super(detailModel);
    }

    @Override
    public void onSelection(Collection<Entity> selectedEntities) {
      Collection<String> continentNames = Entity.values(Continent.NAME, selectedEntities);
      if (detailModel().tableModel().conditionModel().setEqualConditionValues(Country.CONTINENT, continentNames)) {
        detailModel().tableModel().refresh();
      }
    }
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.framework.demos.world.domain.api.World.Country;
import is.codion.framework.demos.world.model.ContinentModel;
import is.codion.swing.framework.model.SwingEntityModel;
import is.codion.swing.framework.ui.EntityPanel;

import org.jfree.chart.ChartPanel;

import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import java.awt.BorderLayout;
import java.awt.Dimension;

import static is.codion.framework.demos.world.ui.ChartPanels.createBarChartPanel;
import static is.codion.framework.demos.world.ui.ChartPanels.createPieChartPanel;
import static is.codion.swing.common.ui.component.Components.*;
import static is.codion.swing.common.ui.layout.Layouts.borderLayout;
import static java.awt.event.KeyEvent.VK_1;
import static java.awt.event.KeyEvent.VK_2;

final class ContinentPanel extends EntityPanel {

  private final EntityPanel countryPanel;

  ContinentPanel(SwingEntityModel continentModel) {
    super(continentModel, new ContinentTablePanel(continentModel.tableModel()),
            new ContinentPanelLayout());
    countryPanel = new EntityPanel(continentModel.detailModel(Country.TYPE));
    countryPanel.tablePanel().configure().includeConditionPanel(false);
  }

  private static final class ContinentPanelLayout implements PanelLayout {

    @Override
    public void layout(EntityPanel entityPanel) {
      ContinentPanel continentPanel = (ContinentPanel) entityPanel;
      ContinentModel model = entityPanel.model();

      ChartPanel populationChartPanel = createPieChartPanel(entityPanel, model.populationDataset(), "Population");
      ChartPanel surfaceAreaChartPanel = createPieChartPanel(entityPanel, model.surfaceAreaDataset(), "Surface area");
      ChartPanel gnpChartPanel = createPieChartPanel(entityPanel, model.gnpDataset(), "GNP");
      ChartPanel lifeExpectancyChartPanel = createBarChartPanel(entityPanel, model.lifeExpectancyDataset(), "Life expectancy", "Continent", "Years");
      lifeExpectancyChartPanel.setPreferredSize(new Dimension(lifeExpectancyChartPanel.getPreferredSize().width, 120));

      Dimension pieChartSize = new Dimension(260, 260);
      populationChartPanel.setPreferredSize(pieChartSize);
      surfaceAreaChartPanel.setPreferredSize(pieChartSize);
      gnpChartPanel.setPreferredSize(pieChartSize);

      JPanel pieChartChartPanel = gridLayoutPanel(1, 3)
              .add(populationChartPanel)
              .add(surfaceAreaChartPanel)
              .add(gnpChartPanel)
              .build();

      JPanel chartPanel = borderLayoutPanel()
              .northComponent(lifeExpectancyChartPanel)
              .centerComponent(pieChartChartPanel)
              .build();

      continentPanel.countryPanel.initialize();
      continentPanel.countryPanel.setPreferredSize(new Dimension(continentPanel.countryPanel.getPreferredSize().width, 100));

      JTabbedPane tabbedPane = tabbedPane()
              .tabBuilder("Charts", chartPanel)
              .mnemonic(VK_1)
              .add()
              .tabBuilder("Countries", continentPanel.countryPanel)
              .mnemonic(VK_2)
              .add()
              .build();

      continentPanel.setLayout(borderLayout());

      continentPanel.add(continentPanel.editControlTablePanel(), BorderLayout.CENTER);
      continentPanel.add(tabbedPane, BorderLayout.SOUTH);

      continentPanel.setupKeyboardActions();
      continentPanel.setupNavigation();
    }
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.framework.model.SwingEntityTableModel;
import is.codion.swing.framework.ui.EntityTablePanel;

import javax.swing.JTable;
import java.util.List;

final class ContinentTablePanel extends EntityTablePanel {

  ContinentTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel);
    configure().includeSouthPanel(false);
    table().setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
  }

  @Override
  protected Controls createPopupMenuControls(List<Controls> additionalPopupMenuControls) {
    return Controls.controls(control(TableControl.REFRESH).get());
  }
}

  interface Lookup {
    EntityType TYPE = DOMAIN.entityType("world.country_city_lookup");

    Column<String> COUNTRY_CODE = TYPE.stringColumn("country.code");
    Column<String> COUNTRY_NAME = TYPE.stringColumn("country.name");
    Column<String> COUNTRY_CONTINENT = TYPE.stringColumn("country.continent");
    Column<String> COUNTRY_REGION = TYPE.stringColumn("country.region");
    Column<Double> COUNTRY_SURFACEAREA = TYPE.doubleColumn("country.surfacearea");
    Column<Integer> COUNTRY_INDEPYEAR = TYPE.integerColumn("country.indepyear");
    Column<Integer> COUNTRY_POPULATION = TYPE.integerColumn("country.population");
    Column<Double> COUNTRY_LIFEEXPECTANCY = TYPE.doubleColumn("country.lifeexpectancy");
    Column<Double> COUNTRY_GNP = TYPE.doubleColumn("country.gnp");
    Column<Double> COUNTRY_GNPOLD = TYPE.doubleColumn("country.gnpold");
    Column<String> COUNTRY_LOCALNAME = TYPE.stringColumn("country.localname");
    Column<String> COUNTRY_GOVERNMENTFORM = TYPE.stringColumn("country.governmentform");
    Column<String> COUNTRY_HEADOFSTATE = TYPE.stringColumn("country.headofstate");
    Column<String> COUNTRY_CODE2 = TYPE.stringColumn("country.code2");
    Column<byte[]> COUNTRY_FLAG = TYPE.byteArrayColumn("country.flag");
    Column<Integer> CITY_ID = TYPE.integerColumn("city.id");
    Column<String> CITY_NAME = TYPE.stringColumn("city.name");
    Column<String> CITY_DISTRICT = TYPE.stringColumn("city.district");
    Column<Integer> CITY_POPULATION = TYPE.integerColumn("city.population");
    Column<Location> CITY_LOCATION = TYPE.column("city.location", Location.class);
  }

  void lookup() {
    add(Lookup.TYPE.define(
            Lookup.COUNTRY_CODE.define()
                    .primaryKey(0)
                    .caption("Country code"),
            Lookup.COUNTRY_NAME.define()
                    .column()
                    .caption("Country name"),
            Lookup.COUNTRY_CONTINENT.define()
                    .column()
                    .caption("Continent")
                    .items(CONTINENT_ITEMS),
            Lookup.COUNTRY_REGION.define()
                    .column()
                    .caption("Region"),
            Lookup.COUNTRY_SURFACEAREA.define()
                    .column()
                    .caption("Surface area")
                    .numberFormatGrouping(true),
            Lookup.COUNTRY_INDEPYEAR.define()
                    .column()
                    .caption("Indep. year"),
            Lookup.COUNTRY_POPULATION.define()
                    .column()
                    .caption("Country population")
                    .numberFormatGrouping(true),
            Lookup.COUNTRY_LIFEEXPECTANCY.define()
                    .column()
                    .caption("Life expectancy"),
            Lookup.COUNTRY_GNP.define()
                    .column()
                    .caption("GNP")
                    .numberFormatGrouping(true),
            Lookup.COUNTRY_GNPOLD.define()
                    .column()
                    .caption("GNP old")
                    .numberFormatGrouping(true),
            Lookup.COUNTRY_LOCALNAME.define()
                    .column()
                    .caption("Local name"),
            Lookup.COUNTRY_GOVERNMENTFORM.define()
                    .column()
                    .caption("Government form"),
            Lookup.COUNTRY_HEADOFSTATE.define()
                    .column()
                    .caption("Head of state"),
            Lookup.COUNTRY_FLAG.define()
                    .column()
                    .caption("Flag")
                    .lazy(true),
            Lookup.COUNTRY_CODE2.define()
                    .column()
                    .caption("Code2"),
            Lookup.CITY_ID.define()
                    .primaryKey(1),
            Lookup.CITY_NAME.define()
                    .column()
                    .caption("City"),
            Lookup.CITY_DISTRICT.define()
                    .column()
                    .caption("District"),
            Lookup.CITY_POPULATION.define()
                    .column()
                    .caption("City population")
                    .numberFormatGrouping(true),
            Lookup.CITY_LOCATION.define()
                    .column()
                    .caption("City location")
                    .columnClass(String.class, new LocationConverter())
                    .comparator(new LocationComparator()))
            .selectQuery(SelectQuery.builder()
                    .from("world.country left outer join world.city on city.countrycode = country.code")
                    .build())
            .orderBy(OrderBy.builder()
                    .ascending(Lookup.COUNTRY_NAME)
                    .descending(Lookup.CITY_POPULATION)
                    .build())
            .readOnly(true)
            .caption("Lookup"));
  }

package is.codion.framework.demos.world.model;

import is.codion.framework.db.EntityConnectionProvider;
import is.codion.framework.demos.world.domain.api.World.Lookup;
import is.codion.framework.domain.entity.Entity;
import is.codion.framework.json.domain.EntityObjectMapper;
import is.codion.swing.framework.model.SwingEntityTableModel;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Collection;
import java.util.List;

import static is.codion.common.Text.textFileContents;
import static is.codion.framework.json.domain.EntityObjectMapper.entityObjectMapper;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Objects.requireNonNull;

public final class LookupTableModel extends SwingEntityTableModel {

  public enum ExportFormat {
    CSV {
      @Override
      public String defaultFileName() {
        return "export.csv";
      }
    },
    JSON {
      @Override
      public String defaultFileName() {
        return "export.json";
      }
    };

    public abstract String defaultFileName();
  }

  private final EntityObjectMapper objectMapper = entityObjectMapper(entities());

  LookupTableModel(EntityConnectionProvider connectionProvider) {
    super(Lookup.TYPE, connectionProvider);
    objectMapper.setIncludeNullValues(false);
  }

  public void export(File file, ExportFormat format) throws IOException {
    requireNonNull(file);
    requireNonNull(format);
    switch (format) {
      case CSV -> exportCSV(file);
      case JSON -> exportJSON(file);
      default -> throw new IllegalArgumentException("Unknown export format: " + format);
    }
  }

  public void importJSON(File file) throws IOException {
    List<Entity> entities = objectMapper.deserializeEntities(textFileContents(file, UTF_8));
    clear();
    conditionModel().clear();
    addItemsAtSorted(0, entities);
  }

  private void exportCSV(File file) throws IOException {
    Files.writeString(file.toPath(), rowsAsDelimitedString(','));
  }

  private void exportJSON(File file) throws IOException {
    Collection<Entity> entities = selectionModel().isSelectionEmpty() ? items() : selectionModel().getSelectedItems();
    Files.writeString(file.toPath(), objectMapper.serializeEntities(entities));
  }
}

package is.codion.framework.demos.world.ui;

import is.codion.common.state.State;
import is.codion.framework.demos.world.domain.api.World.Lookup;
import is.codion.framework.demos.world.model.LookupTableModel;
import is.codion.framework.demos.world.model.LookupTableModel.ExportFormat;
import is.codion.framework.domain.entity.Entity;
import is.codion.swing.common.ui.Utilities;
import is.codion.swing.common.ui.component.button.ToggleButtonType;
import is.codion.swing.common.ui.control.Control;
import is.codion.swing.common.ui.control.Controls;
import is.codion.swing.common.ui.control.ToggleControl;
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 org.jxmapviewer.JXMapKit;
import org.kordamp.ikonli.foundation.Foundation;

import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JToolBar;
import javax.swing.SwingConstants;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;

import static is.codion.framework.demos.world.model.LookupTableModel.ExportFormat.CSV;
import static is.codion.framework.demos.world.model.LookupTableModel.ExportFormat.JSON;
import static is.codion.swing.common.ui.component.Components.scrollPane;
import static is.codion.swing.common.ui.component.Components.toolBar;
import static java.util.stream.Collectors.toSet;
import static javax.swing.BorderFactory.createTitledBorder;

final class LookupTablePanel extends EntityTablePanel {

  private static final Dimension DEFAULT_MAP_SIZE = new Dimension(400, 400);

  private final State columnSelectionPanelVisible = State.state(true);
  private final State mapDialogVisible = State.state();

  private final Control toggleMapControl = ToggleControl.builder(mapDialogVisible)
          .smallIcon(FrameworkIcons.instance().icon(Foundation.MAP))
          .name("Show map")
          .build();
  private final JScrollPane columnSelectionScrollPane = scrollPane(createColumnSelectionToolBar())
          .verticalUnitIncrement(16)
          .build();
  private final JXMapKit mapKit = Maps.createMapKit();

  private JDialog mapKitDialog;

  LookupTablePanel(SwingEntityTableModel lookupModel) {
    super(lookupModel);
    columnSelectionPanelVisible.addDataListener(this::setColumnSelectionPanelVisible);
    table().setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
    conditionPanelVisible().set(true);
    showRefreshProgressBar().set(true);
    bindEvents();
  }

  @Override
  public void updateUI() {
    super.updateUI();
    Utilities.updateComponentTreeUI(mapKit);
  }

  @Override
  protected void setupControls() {
    control(TableControl.CLEAR).set(Control.builder(this::clearTableAndConditions)
            .name("Clear")
            .mnemonic('C')
            .smallIcon(FrameworkIcons.instance().clear())
            .build());
    control(TableControl.SELECT_COLUMNS).set(ToggleControl.builder(columnSelectionPanelVisible)
            .name("Select")
            .build());
  }

  @Override
  protected Controls createPopupMenuControls(List<Controls> additionalPopupMenuControls) {
    FrameworkIcons icons = FrameworkIcons.instance();

    return super.createPopupMenuControls(additionalPopupMenuControls)
            .addSeparatorAt(2)
            .addAt(3, Controls.builder()
                    .name("Export")
                    .smallIcon(icons.icon(Foundation.PAGE_EXPORT))
                    .control(Control.builder(this::exportCSV)
                            .name("CSV..."))
                    .control(Control.builder(this::exportJSON)
                            .name("JSON..."))
                    .build())
            .addAt(4, Controls.builder()
                    .name("Import")
                    .smallIcon(icons.icon(Foundation.PAGE_ADD))
                    .control(Control.builder(this::importJSON)
                            .name("JSON..."))
                    .build())
            .addSeparatorAt(5)
            .addAt(6, toggleMapControl);
  }

  @Override
  protected Controls createToolBarControls(List<Controls> additionalToolBarControls) {
    return super.createToolBarControls(additionalToolBarControls)
            .addAt(0, toggleMapControl);
  }

  @Override
  protected void layoutPanel(JComponent tableComponent, JPanel southPanel) {
    super.layoutPanel(tableComponent, southPanel);
    add(columnSelectionScrollPane, BorderLayout.EAST);
  }

  private void bindEvents() {
    mapDialogVisible.addDataListener(this::setMapDialogVisible);
    tableModel().addDataChangedListener(this::displayCityLocations);
    tableModel().selectionModel().addSelectionListener(this::displayCityLocations);
  }

  private void displayCityLocations() {
    if (mapKit.isShowing()) {
      Collection<Entity> entities = tableModel().selectionModel().isSelectionEmpty() ?
              tableModel().visibleItems() :
              tableModel().selectionModel().getSelectedItems();
      Maps.paintWaypoints(entities.stream()
              .filter(entity -> entity.isNotNull(Lookup.CITY_LOCATION))
              .map(entity -> entity.get(Lookup.CITY_LOCATION))
              .collect(toSet()), mapKit.getMainMap());
    }
  }

  private void setMapDialogVisible(boolean visible) {
    if (mapKitDialog == null) {
      mapKitDialog = Dialogs.componentDialog(mapKit)
              .owner(this)
              .modal(false)
              .title("World Map")
              .size(DEFAULT_MAP_SIZE)
              .onShown(dialog -> displayCityLocations())
              .onClosed(e -> mapDialogVisible.set(false))
              .build();
    }
    mapKitDialog.setVisible(visible);
  }

  private void exportCSV() {
    export(CSV);
  }

  private void exportJSON() {
    export(JSON);
  }

  private void export(ExportFormat format) {
    File fileToSave = Dialogs.fileSelectionDialog()
            .owner(this)
            .selectFileToSave(format.defaultFileName());
    LookupTableModel lookupTableModel = tableModel();
    Dialogs.progressWorkerDialog(() -> lookupTableModel.export(fileToSave, format))
            .owner(this)
            .title("Exporting data")
            .onResult("Export successful")
            .onException("Export failed")
            .execute();
  }

  private void importJSON() throws IOException {
    File file = Dialogs.fileSelectionDialog()
            .owner(this)
            .fileFilter(new FileNameExtensionFilter("JSON", "json"))
            .selectFile();
    LookupTableModel tableModel = tableModel();
    tableModel.importJSON(file);
  }

  private JToolBar createColumnSelectionToolBar() {
    Controls toggleColumnsControls = table().createToggleColumnsControls();

    return toolBar(Controls.controls()
            .add(createSelectAllColumnsControl(toggleColumnsControls))
            .addSeparator()
            .addAll(toggleColumnsControls))
            .floatable(false)
            .orientation(SwingConstants.VERTICAL)
            .toggleButtonType(ToggleButtonType.CHECKBOX)
            .includeButtonText(true)
            .border(createTitledBorder("Columns"))
            .build();
  }

  private void setColumnSelectionPanelVisible(boolean visible) {
    columnSelectionScrollPane.setVisible(visible);
    revalidate();
  }

  private void clearTableAndConditions() {
    tableModel().clear();
    tableModel().conditionModel().clear();
  }

  private static Control createSelectAllColumnsControl(Controls toggleColumnsControls) {
    return Control.builder(() -> toggleColumnsControls.actions().stream()
                    .map(ToggleControl.class::cast)
                    .forEach(toggleControl -> toggleControl.value().set(true)))
            .name("Select all")
            .smallIcon(FrameworkIcons.instance().icon(Foundation.CHECK))
            .build();
  }
}