is.codion.framework.model.AbstractEntityEditModel Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of codion-framework-model Show documentation
Show all versions of codion-framework-model Show documentation
Codion Application Framework
/*
* This file is part of Codion.
*
* Codion is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Codion is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Codion. If not, see entitySearchModels = new HashMap<>();
private final Events events;
private final States states;
/**
* Instantiates a new {@link AbstractEntityEditModel} based on the given entity type.
* @param entityType the type of the entity to base this {@link AbstractEntityEditModel} on
* @param connectionProvider the {@link EntityConnectionProvider} instance
*/
protected AbstractEntityEditModel(EntityType entityType, EntityConnectionProvider connectionProvider) {
EntityDefinition entityDefinition = requireNonNull(connectionProvider).entities().definition(requireNonNull(entityType));
this.editable = new DefaultEditableEntity(entityDefinition, connectionProvider);
this.states = new States(entityDefinition.readOnly());
this.events = new Events(states.postEditEvents);
}
@Override
public final Entities entities() {
return editable.connectionProvider.entities();
}
@Override
public final EntityDefinition entityDefinition() {
return editable.entityDefinition;
}
@Override
public final String toString() {
return getClass() + ", " + editable.entity.entityType();
}
@Override
public final State postEditEvents() {
return states.postEditEvents;
}
@Override
public final State readOnly() {
return states.readOnly;
}
@Override
public final State insertEnabled() {
return states.insertEnabled;
}
@Override
public final State updateEnabled() {
return states.updateEnabled;
}
@Override
public final State updateMultipleEnabled() {
return states.updateMultipleEnabled;
}
@Override
public final State deleteEnabled() {
return states.deleteEnabled;
}
@Override
public final EntityType entityType() {
return editable.entity.entityType();
}
@Override
public final EntityConnectionProvider connectionProvider() {
return editable.connectionProvider;
}
@Override
public final EntityConnection connection() {
return connectionProvider().connection();
}
@Override
public final void replace(ForeignKey foreignKey, Collection entities) {
replaceForeignKey(requireNonNull(foreignKey), requireNonNull(entities));
}
@Override
public final EditableEntity entity() {
return editable;
}
@Override
public final EditableValue value(Attribute attribute) {
return editable.value(attribute);
}
@Override
public final void validate(Attribute attribute) throws ValidationException {
editable.validator.get().validate(editable.entity, attribute);
}
@Override
public final void validate(Collection entities) throws ValidationException {
for (Entity entityToValidate : requireNonNull(entities)) {
validate(entityToValidate);
}
}
@Override
public final void validate(Entity entity) throws ValidationException {
if (entity.entityType().equals(entityType())) {
editable.validator.get().validate(entity);
}
else {
entity.definition().validator().validate(entity);
}
}
@Override
public final Entity insert() throws DatabaseException, ValidationException {
return createInsert().prepare().perform().handle().iterator().next();
}
@Override
public final Collection insert(Collection entities) throws DatabaseException, ValidationException {
return createInsert(entities).prepare().perform().handle();
}
@Override
public final Entity update() throws DatabaseException, ValidationException {
return createUpdate().prepare().perform().handle().iterator().next();
}
@Override
public final Collection update(Collection entities) throws DatabaseException, ValidationException {
return createUpdate(entities).prepare().perform().handle();
}
@Override
public final Entity delete() throws DatabaseException {
return createDelete().prepare().perform().handle().iterator().next();
}
@Override
public final Collection delete(Collection entities) throws DatabaseException {
return createDelete(entities).prepare().perform().handle();
}
@Override
public final Insert createInsert() throws ValidationException {
return new DefaultInsert();
}
@Override
public final Insert createInsert(Collection entities) throws ValidationException {
return new DefaultInsert(entities);
}
@Override
public final Update createUpdate() throws ValidationException {
return new DefaultUpdate();
}
@Override
public final Update createUpdate(Collection entities) throws ValidationException {
return new DefaultUpdate(entities);
}
@Override
public final Delete createDelete() {
return new DefaultDelete();
}
@Override
public final Delete createDelete(Collection entities) {
return new DefaultDelete(entities);
}
@Override
public EntitySearchModel createForeignKeySearchModel(ForeignKey foreignKey) {
entityDefinition().foreignKeys().definition(foreignKey);
Collection> searchable = entities().definition(foreignKey.referencedType()).columns().searchable();
if (searchable.isEmpty()) {
throw new IllegalStateException("No searchable columns defined for entity: " + foreignKey.referencedType());
}
return EntitySearchModel.builder(foreignKey.referencedType(), connectionProvider())
.columns(searchable)
.singleSelection(true)
.build();
}
@Override
public final EntitySearchModel foreignKeySearchModel(ForeignKey foreignKey) {
entityDefinition().foreignKeys().definition(foreignKey);
synchronized (entitySearchModels) {
// can't use computeIfAbsent here, see comment in SwingEntityEditModel.foreignKeyComboBoxModel()
EntitySearchModel entitySearchModel = entitySearchModels.get(foreignKey);
if (entitySearchModel == null) {
entitySearchModel = createForeignKeySearchModel(foreignKey);
entitySearchModels.put(foreignKey, entitySearchModel);
}
return entitySearchModel;
}
}
@Override
public final Observer> beforeInsert() {
return events.beforeInsert.observer();
}
@Override
public final Observer> afterInsert() {
return events.afterInsert.observer();
}
@Override
public final Observer> beforeUpdate() {
return events.beforeUpdate.observer();
}
@Override
public final Observer> afterUpdate() {
return events.afterUpdate.observer();
}
@Override
public final Observer> beforeDelete() {
return events.beforeDelete.observer();
}
@Override
public final Observer> afterDelete() {
return events.afterDelete.observer();
}
@Override
public final Observer afterInsertUpdateOrDelete() {
return events.afterInsertUpdateOrDelete.observer();
}
/**
* Inserts the given entities into the database using the given connection
* @param entities the entities to insert
* @param connection the connection to use
* @return the inserted entities
* @throws DatabaseException in case of a database exception
*/
protected Collection insert(Collection entities, EntityConnection connection) throws DatabaseException {
return requireNonNull(connection).insertSelect(entities);
}
/**
* Updates the given entities in the database using the given connection
* @param entities the entities to update
* @param connection the connection to use
* @return the updated entities
* @throws DatabaseException in case of a database exception
*/
protected Collection update(Collection entities, EntityConnection connection) throws DatabaseException {
return requireNonNull(connection).updateSelect(entities);
}
/**
* Deletes the given entities from the database using the given connection
* @param entities the entities to delete
* @param connection the connection to use
* @throws DatabaseException in case of a database exception
*/
protected void delete(Collection entities, EntityConnection connection) throws DatabaseException {
requireNonNull(connection).delete(Entity.primaryKeys(entities));
}
/**
* For every field referencing the given foreign key values, replaces that foreign key instance with
* the corresponding entity from {@code values}, useful when attribute
* values have been changed in the referenced entity that must be reflected in the edit model.
* @param foreignKey the foreign key attribute
* @param values the foreign key entities
*/
protected void replaceForeignKey(ForeignKey foreignKey, Collection values) {
Entity currentForeignKeyValue = editable.entity.entity(foreignKey);
if (currentForeignKeyValue != null) {
for (Entity replacementValue : values) {
if (currentForeignKeyValue.equals(replacementValue)) {
value(foreignKey).clear();
value(foreignKey).set(replacementValue);
}
}
}
}
/**
* Notifies that insert is about to be performed
* @param entitiesToInsert the entities about to be inserted
* @see #beforeInsert()
*/
protected final void notifyBeforeInsert(Collection entitiesToInsert) {
events.beforeInsert.accept(requireNonNull(entitiesToInsert));
}
/**
* Notifies that insert has been performed
* @param insertedEntities the inserted entities
* @see #afterInsert()
*/
protected final void notifyAfterInsert(Collection insertedEntities) {
events.afterInsert.accept(requireNonNull(insertedEntities));
}
/**
* Notifies that update is about to be performed
* @param entitiesToUpdate the entities about to be updated
* @see #beforeUpdate()
*/
protected final void notifyBeforeUpdate(Map entitiesToUpdate) {
events.beforeUpdate.accept(requireNonNull(entitiesToUpdate));
}
/**
* Notifies that update has been performed
* @param updatedEntities the updated entities
* @see #afterUpdate()
*/
protected final void notifyAfterUpdate(Map updatedEntities) {
events.afterUpdate.accept(requireNonNull(updatedEntities));
}
/**
* Notifies that delete is about to be performed
* @param entitiesToDelete the entities about to be deleted
* @see #beforeDelete()
*/
protected final void notifyBeforeDelete(Collection entitiesToDelete) {
events.beforeDelete.accept(requireNonNull(entitiesToDelete));
}
/**
* Notifies that delete has been performed
* @param deletedEntities the deleted entities
* @see #afterDelete()
*/
protected final void notifyAfterDelete(Collection deletedEntities) {
events.afterDelete.accept(requireNonNull(deletedEntities));
}
/**
* Maps the given entities and their updated counterparts to their original primary keys,
* assumes a single copy of each entity in the given lists.
* @param entitiesBeforeUpdate the entities before update
* @param entitiesAfterUpdate the entities after update
* @return the updated entities mapped to their respective original primary keys
*/
private static Map originalPrimaryKeyMap(Collection entitiesBeforeUpdate,
Collection entitiesAfterUpdate) {
List entitiesAfterUpdateCopy = new ArrayList<>(entitiesAfterUpdate);
Map keyMap = new HashMap<>(entitiesBeforeUpdate.size());
for (Entity entity : entitiesBeforeUpdate) {
keyMap.put(entity.originalPrimaryKey(), findAndRemove(entity.primaryKey(), entitiesAfterUpdateCopy.listIterator()));
}
return unmodifiableMap(keyMap);
}
private static Entity findAndRemove(Entity.Key primaryKey, ListIterator iterator) {
while (iterator.hasNext()) {
Entity current = iterator.next();
if (current.primaryKey().equals(primaryKey)) {
iterator.remove();
return current;
}
}
return null;
}
private interface ValueSupplier {
T get(AttributeDefinition attributeDefinition);
}
private final class DefaultInsert implements Insert {
private final Collection entities;
private final boolean activeEntity;
private DefaultInsert() throws ValidationException {
this.entities = entityForInsert();
this.activeEntity = true;
states.verifyInsertEnabled();
validate(entities);
}
private DefaultInsert(Collection entities) throws ValidationException {
this.entities = unmodifiableCollection(new ArrayList<>(entities));
this.activeEntity = false;
states.verifyInsertEnabled();
validate(entities);
}
private Collection entityForInsert() {
Entity toInsert = editable.entity.copy().mutable();
if (toInsert.definition().primaryKey().generated()) {
toInsert.clearPrimaryKey();
}
return singleton(toInsert);
}
@Override
public Task prepare() {
notifyBeforeInsert(entities);
return new InsertTask();
}
private final class InsertTask implements Task {
@Override
public Result perform() throws DatabaseException {
LOG.debug("{} - insert {}", this, entities);
Collection inserted = unmodifiableCollection(insert(entities, connection()));
if (!entities.isEmpty() && inserted.isEmpty()) {
throw new DatabaseException("Insert did not return an entity, usually caused by a misconfigured key generator");
}
return new InsertResult(inserted);
}
}
private final class InsertResult implements Result {
private final Collection insertedEntities;
private InsertResult(Collection insertedEntities) {
this.insertedEntities = insertedEntities;
}
@Override
public Collection handle() {
if (activeEntity) {
editable.setOrDefaults(insertedEntities.iterator().next());
}
notifyAfterInsert(insertedEntities);
return insertedEntities;
}
}
}
private final class DefaultUpdate implements Update {
private final Collection entities;
private DefaultUpdate() throws ValidationException {
entities = singleton(editable.entity.copy().mutable());
states.verifyUpdateEnabled(entities.size());
validate(entities);
verifyModified(entities);
}
private DefaultUpdate(Collection entities) throws ValidationException {
this.entities = unmodifiableCollection(new ArrayList<>(entities));
states.verifyUpdateEnabled(entities.size());
validate(entities);
verifyModified(entities);
}
@Override
public Task prepare() {
notifyBeforeUpdate(unmodifiableMap(entities.stream().collect(toMap(Entity::originalPrimaryKey, Function.identity()))));
return new UpdateTask();
}
private void verifyModified(Collection entities) {
for (Entity entityToUpdate : entities) {
if (!entityToUpdate.modified()) {
throw new IllegalArgumentException("Entity is not modified: " + entityToUpdate);
}
}
}
private final class UpdateTask implements Task {
@Override
public Result perform() throws DatabaseException {
LOG.debug("{} - update {}", this, entities);
return new UpdateResult(update(entities, connection()));
}
}
private final class UpdateResult implements Result {
private final Collection updatedEntities;
private UpdateResult(Collection updatedEntities) {
this.updatedEntities = updatedEntities;
}
@Override
public Collection handle() {
Entity entity = editable.get();
updatedEntities.stream()
.filter(updatedEntity -> updatedEntity.equals(entity))
.findFirst()
.ifPresent(editable::setOrDefaults);
notifyAfterUpdate(originalPrimaryKeyMap(entities, updatedEntities));
return updatedEntities;
}
}
}
private final class DefaultDelete implements Delete {
private final Collection entities;
private final boolean activeEntity;
private DefaultDelete() {
this.entities = singleton(activeEntity());
this.activeEntity = true;
states.verifyDeleteEnabled();
}
private DefaultDelete(Collection entities) {
this.entities = unmodifiableCollection(new ArrayList<>(entities));
this.activeEntity = false;
states.verifyDeleteEnabled();
}
@Override
public Task prepare() {
notifyBeforeDelete(entities);
return new DeleteTask();
}
private Entity activeEntity() {
Entity copy = editable.entity.copy().mutable();
copy.revert();
return copy;
}
private final class DeleteTask implements Task {
@Override
public Result perform() throws DatabaseException {
LOG.debug("{} - delete {}", this, entities);
delete(entities, connection());
return new DeleteResult(entities);
}
}
private final class DeleteResult implements Result {
private final Collection deletedEntities;
private DeleteResult(Collection deletedEntities) {
this.deletedEntities = deletedEntities;
}
@Override
public Collection handle() {
if (activeEntity) {
editable.setOrDefaults(null);
}
notifyAfterDelete(deletedEntities);
return deletedEntities;
}
}
}
private static final class Events {
private final Event> beforeInsert = Event.event();
private final Event> afterInsert = Event.event();
private final Event> beforeUpdate = Event.event();
private final Event> afterUpdate = Event.event();
private final Event> beforeDelete = Event.event();
private final Event> afterDelete = Event.event();
private final Event afterInsertUpdateOrDelete = Event.event();
private Events(StateObserver postEditEvents) {
afterInsert.addListener(afterInsertUpdateOrDelete);
afterUpdate.addListener(afterInsertUpdateOrDelete);
afterDelete.addListener(afterInsertUpdateOrDelete);
afterInsert.addConsumer(insertedEntities -> {
if (postEditEvents.get()) {
inserted(insertedEntities);
}
});
afterUpdate.addConsumer(updatedEntities -> {
if (postEditEvents.get()) {
updated(updatedEntities);
}
});
afterDelete.addConsumer(deletedEntities -> {
if (postEditEvents.get()) {
deleted(deletedEntities);
}
});
}
}
private static final class States {
private final State readOnly;
private final State insertEnabled = State.state(true);
private final State updateEnabled = State.state(true);
private final State updateMultipleEnabled = State.state(true);
private final State deleteEnabled = State.state(true);
private final State postEditEvents = State.state(POST_EDIT_EVENTS.get());
private States(boolean readOnly) {
this.readOnly = State.state(readOnly);
}
private void verifyInsertEnabled() {
if (readOnly.get() || !insertEnabled.get()) {
throw new IllegalStateException("Edit model is readOnly or inserting is not enabled!");
}
}
private void verifyUpdateEnabled(int entityCount) {
if (readOnly.get() || !updateEnabled.get()) {
throw new IllegalStateException("Edit model is readOnly or updating is not enabled!");
}
if (entityCount > 1 && !updateMultipleEnabled.get()) {
throw new IllegalStateException("Updating multiple entities is not enabled");
}
}
private void verifyDeleteEnabled() {
if (readOnly.get() || !deleteEnabled.get()) {
throw new IllegalStateException("Edit model is readOnly or deleting is not enabled!");
}
}
}
private static final class DefaultEditableEntity implements EditableEntity {
private final Map, Event> editEvents = new HashMap<>();
private final Event> valueChanged = Event.event();
private final Event changing = Event.event();
private final Event changed = Event.event();
private final Map, DefaultEditableValue> editableValues = new HashMap<>();
private final Map, State> persistValues = new HashMap<>();
private final Map, State> attributeModified = new HashMap<>();
private final Map, State> attributeNull = new HashMap<>();
private final Map, State> attributeValid = new HashMap<>();
private final EntityDefinition entityDefinition;
private final EntityConnectionProvider connectionProvider;
private final State primaryKeyNull = State.state(true);
private final State entityValid = State.state();
private final DefaultExists exists;
private final DefaultModified modified;
private final StateObserver editing;
private final Value validator;
private final Entity entity;
private DefaultEditableEntity(EntityDefinition entityDefinition, EntityConnectionProvider connectionProvider) {
this.entityDefinition = entityDefinition;
this.connectionProvider = connectionProvider;
this.entity = createEntity(AttributeDefinition::defaultValue);
this.exists = new DefaultExists(entity.definition());
this.modified = new DefaultModified();
this.editing = State.and(exists.exists, modified.modified);
this.validator = Value.builder()
.nonNull(entityDefinition.validator())
.listener(this::updateValidState)
.build();
configurePersistentForeignKeys();
}
@Override
public void set(Entity entity) {
changing.accept(entity);
setOrDefaults(entity);
}
@Override
public Entity get() {
return entity.immutable();
}
@Override
public void clear() {
set(entityDefinition.entity());
}
@Override
public Observer observer() {
return changed.observer();
}
@Override
public void defaults() {
set(null);
}
@Override
public void refresh() {
try {
if (exists.get()) {
set(connectionProvider.connection().select(entity.primaryKey()));
}
}
catch (DatabaseException e) {
throw new RuntimeException(e);
}
}
@Override
public void revert() {
entityDefinition.attributes().get().forEach(attribute -> value(attribute).revert());
}
@Override
public Exists exists() {
return exists;
}
@Override
public Modified modified() {
return modified;
}
@Override
public StateObserver edited() {
return editing;
}
@Override
public Observer changing() {
return changing.observer();
}
@Override
public Observer> valueChanged() {
return valueChanged.observer();
}
@Override
public boolean nullable(Attribute attribute) {
return validator.get().nullable(entity, attribute);
}
@Override
public StateObserver isNull(Attribute attribute) {
return attributeNull.computeIfAbsent(attribute,
k -> State.state(entity.isNull(attribute))).observer();
}
@Override
public StateObserver isNotNull(Attribute attribute) {
return attributeNull.computeIfAbsent(attribute,
k -> State.state(entity.isNull(attribute))).observer().not();
}
@Override
public StateObserver primaryKeyNull() {
return primaryKeyNull.observer();
}
@Override
public Value validator() {
return validator;
}
@Override
public StateObserver valid() {
return entityValid.observer();
}
@Override
public void validate() throws ValidationException {
validate(entity);
}
@Override
public EditableValue value(Attribute attribute) {
entityDefinition.attributes().definition(attribute);
return (EditableValue) editableValues.computeIfAbsent(attribute, k -> new DefaultEditableValue<>(attribute));
}
private void setOrDefaults(Entity entity) {
Map, Object> affectedAttributes = this.entity.set(entity == null ? createEntity(this::defaultValue) : entity);
for (Attribute affectedAttribute : affectedAttributes.keySet()) {
notifyValueChange(affectedAttribute);
}
if (affectedAttributes.isEmpty()) {//otherwise notifyValueChange() triggers entity state updates
updateStates();
}
attributeModified.forEach(this::updateAttributeModifiedState);
changed.accept(entity);
}
private T defaultValue(AttributeDefinition attributeDefinition) {
if (value(attributeDefinition.attribute()).persist().get()) {
if (attributeDefinition instanceof ForeignKeyDefinition) {
return (T) entity.entity((ForeignKey) attributeDefinition.attribute());
}
return entity.get(attributeDefinition.attribute());
}
return value(attributeDefinition.attribute()).defaultValue().get().get();
}
private void notifyValueEdit(Attribute attribute, T value, Map, Object> dependingValues) {
notifyValueChange(attribute);
Event editEvent = (Event) editEvents.get(attribute);
if (editEvent != null) {
editEvent.accept(value);
}
dependingValues.forEach((dependingAttribute, previousValue) -> {
Object currentValue = entity.get(dependingAttribute);
if (!Objects.equals(previousValue, currentValue)) {
notifyValueEdit((Attribute © 2015 - 2025 Weber Informatics LLC | Privacy Policy