* <li><code>ReferenceEditorPresenter.guaranteePerEntityCRUDPermissions(...)</code></li>
* <li><code>PersonField.commit()</code></li>
* <li><code>TeamOrPersonField.commit()</code></li>
- * <li><code>SpecimenTypeDesignationWorkingsetEditorPresenter.saveBean(SpecimenTypeDesignationWorkingSetDTO dto)</code></li>
+ * <li><code>SpecimenTypeDesignationSetEditorPresenter.saveBean(SpecimenTypeDesignationSetDTO dto)</code></li>
* </ul>
*
* @param reg the Registration
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.name.Registration;
-import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationWorkingSetDTO;
+import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationSetDTO;
/**
* @author a.kohlbecker
* @since May 4, 2017
*
*/
-public interface ISpecimenTypeDesignationWorkingSetService {
+public interface ISpecimenTypeDesignationSetService {
- public SpecimenTypeDesignationWorkingSetDTO<Registration> create(UUID registrationUuid, UUID typifiedNameUuid);
+ public SpecimenTypeDesignationSetDTO<Registration> create(UUID registrationUuid, UUID typifiedNameUuid);
/**
* @param id the CDM Entity id
* @return
*/
- public SpecimenTypeDesignationWorkingSetDTO<Registration> load(UUID registrationUuid,
+ public SpecimenTypeDesignationSetDTO<Registration> load(UUID registrationUuid,
IdentifiableEntity<?> baseEntityRef);
- public SpecimenTypeDesignationWorkingSetDTO<Registration> fixMissingFieldUnit(SpecimenTypeDesignationWorkingSetDTO<Registration> bean);
+ public SpecimenTypeDesignationSetDTO<Registration> fixMissingFieldUnit(SpecimenTypeDesignationSetDTO<Registration> bean);
/**
- * Saves the SpecimenTypeDesignationWorkingSetDTO and takes care for consistency in the working set:
+ * Saves the {@link SpecimenTypeDesignationSetDTO} and takes care for consistency in the working set:
* <ul>
* <li>New TypeDesignations are associated with the OWNER.</li>
* <li>The citation and typified name of newly created TypeDesignations are set.</li>
*
* @param dto the DTO to be persisted
*/
- void save(SpecimenTypeDesignationWorkingSetDTO<? extends VersionableEntity> dto);
+ void save(SpecimenTypeDesignationSetDTO<? extends VersionableEntity> dto);
/**
- * @param bean The SpecimenTypeDesignationWorkingSetDTO to be deleted
+ * @param bean The {@link SpecimenTypeDesignationSetDTO} to be deleted
* @param deleteFieldUnit The fieldunit and all derivatives which is the base entity of the workingset will
* also be deleted once this is set to <code>true</code>.
*/
- public void delete(SpecimenTypeDesignationWorkingSetDTO bean, boolean deleteFieldUnit);
+ public void delete(SpecimenTypeDesignationSetDTO bean, boolean deleteFieldUnit);
}
import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;
-import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationWorkingSetDTO;
+import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationSetDTO;
/**
* @author a.kohlbecker
* @since Nov 13, 2017
*/
-@Service("specimenTypeDesignationWorkingSetService")
+@Service("specimenTypeDesignationSetService")
@Transactional(readOnly=true)
-public class SpecimenTypeDesignationWorkingSetServiceImpl
- implements ISpecimenTypeDesignationWorkingSetService {
+public class SpecimenTypeDesignationSetServiceImpl
+ implements ISpecimenTypeDesignationSetService {
- private final Logger logger = Logger.getLogger(SpecimenTypeDesignationWorkingSetServiceImpl.class);
+ private final Logger logger = Logger.getLogger(SpecimenTypeDesignationSetServiceImpl.class);
static SpecimenDeleteConfigurator specimenDeleteConfigurer = new SpecimenDeleteConfigurator();
static {
CdmRepository repo;
@Override
- public SpecimenTypeDesignationWorkingSetDTO<Registration> create(UUID registrationUuid, UUID typifiedNameUuid) {
+ public SpecimenTypeDesignationSetDTO<Registration> create(UUID registrationUuid, UUID typifiedNameUuid) {
FieldUnit newfieldUnit = FieldUnit.NewInstance();
Registration reg = repo.getRegistrationService().load(registrationUuid, RegistrationWorkingSetService.REGISTRATION_DTO_INIT_STRATEGY.getPropertyPaths());
if(reg == null){
reg.setUuid(registrationUuid);
}
TaxonName typifiedName = repo.getNameService().load(typifiedNameUuid, TAXON_NAME_INIT_STRATEGY);
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingSetDto = new SpecimenTypeDesignationWorkingSetDTO<>(reg, newfieldUnit, typifiedName);
+ SpecimenTypeDesignationSetDTO<Registration> workingSetDto = new SpecimenTypeDesignationSetDTO<>(reg, newfieldUnit, typifiedName);
return workingSetDto;
}
@Override
@Transactional(readOnly=true)
- public SpecimenTypeDesignationWorkingSetDTO<Registration> load(UUID registrationUuid, IdentifiableEntity<?> baseEntity) {
+ public SpecimenTypeDesignationSetDTO<Registration> load(UUID registrationUuid, IdentifiableEntity<?> baseEntity) {
RegistrationDTO regDTO = registrationWorkingSetService.loadDtoByUuid(registrationUuid);
// find the working set
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingSetDto = specimenTypeDesignationWorkingSetDTO(regDTO, baseEntity);
+ SpecimenTypeDesignationSetDTO<Registration> workingSetDto = specimenTypeDesignationSetDTO(regDTO, baseEntity);
return workingSetDto;
}
- protected SpecimenTypeDesignationWorkingSetDTO<Registration> specimenTypeDesignationWorkingSetDTO(
+ protected SpecimenTypeDesignationSetDTO<Registration> specimenTypeDesignationSetDTO(
RegistrationDTO regDTO, VersionableEntity baseEntity) {
Set<TypeDesignationBase> typeDesignations = regDTO.getTypeDesignationsInWorkingSet(baseEntity);
typeDesignations.forEach(td -> specimenTypeDesignations.add((SpecimenTypeDesignation)td));
specimenTypeDesignations.sort(new TypeDesignationComparator());
//TODO is this needed?
- baseEntity = regDTO.getTypeDesignationWorkingSet(baseEntity).getBaseEntity();
+ baseEntity = regDTO.getTypeDesignationSet(baseEntity).getBaseEntity();
- SpecimenTypeDesignationWorkingSetDTO<Registration> dto = new SpecimenTypeDesignationWorkingSetDTO<>(regDTO.registration(),
+ SpecimenTypeDesignationSetDTO<Registration> dto = new SpecimenTypeDesignationSetDTO<>(regDTO.registration(),
baseEntity, specimenTypeDesignations, regDTO.typifiedName());
return dto;
}
@Override
- public SpecimenTypeDesignationWorkingSetDTO<Registration> fixMissingFieldUnit(SpecimenTypeDesignationWorkingSetDTO<Registration> bean) {
+ public SpecimenTypeDesignationSetDTO<Registration> fixMissingFieldUnit(SpecimenTypeDesignationSetDTO<Registration> bean) {
if(bean.getFieldUnit() == null){
// in case the base unit of the working set is not a FieldUnit all contained TypeDesignations must be modified
@Override
@Transactional(readOnly=false)
- public void save(SpecimenTypeDesignationWorkingSetDTO<? extends VersionableEntity> dto) {
+ public void save(SpecimenTypeDesignationSetDTO<? extends VersionableEntity> dto) {
if(dto.getOwner() instanceof Registration){
Registration regPremerge = (Registration) dto.getOwner();
regPremerge = repo.getRegistrationService().assureIsPersisted(regPremerge);
// find the newly created type designations
- Set<SpecimenTypeDesignation> newTypeDesignations = findNewTypeDesignations((SpecimenTypeDesignationWorkingSetDTO<Registration>) dto);
+ Set<SpecimenTypeDesignation> newTypeDesignations = findNewTypeDesignations((SpecimenTypeDesignationSetDTO<Registration>) dto);
FieldUnit fieldUnit = (FieldUnit) dto.getBaseEntity();
* @param specimenDeleteConfigurer
* @param std
*/
- protected void deleteSpecimenTypeDesignation(SpecimenTypeDesignationWorkingSetDTO<? extends VersionableEntity> dto, SpecimenTypeDesignation std) {
+ protected void deleteSpecimenTypeDesignation(SpecimenTypeDesignationSetDTO<? extends VersionableEntity> dto, SpecimenTypeDesignation std) {
// if(dto.getOwner() instanceof Registration){
// Registration registration = (Registration) dto.getOwner();
return original;
}
- private Set<SpecimenTypeDesignation> findNewTypeDesignations(SpecimenTypeDesignationWorkingSetDTO<Registration> workingSetDto) {
+ private Set<SpecimenTypeDesignation> findNewTypeDesignations(SpecimenTypeDesignationSetDTO<Registration> workingSetDto) {
Registration reg = workingSetDto.getOwner();
Set<SpecimenTypeDesignation> addCandidates = new HashSet<>();
*/
@Override
@Transactional(readOnly=false)
- public void delete(SpecimenTypeDesignationWorkingSetDTO bean, boolean deleteFieldUnit) {
+ public void delete(SpecimenTypeDesignationSetDTO bean, boolean deleteFieldUnit) {
@SuppressWarnings("unchecked")
List<SpecimenTypeDesignationDTO> specimenTypeDesignationDTOs = bean.getSpecimenTypeDesignationDTOs();
import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;
import eu.etaxonomy.cdm.api.service.name.TypeDesignationDTO;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetFormatter;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
import eu.etaxonomy.cdm.api.util.UserHelper;
import eu.etaxonomy.cdm.model.ICdmEntityUuidCacher;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
private IdButton<TaxonName> nameIdButton = null;
- private List<TypeDesignationWorkingSetButton> typeDesignationButtons = new ArrayList<>();
+ private List<TypeDesignationSetButton> typeDesignationButtons = new ArrayList<>();
private List<Label> labels = new ArrayList<>();
}
}
boolean userHasAddPermission = !regDto.isPersisted() || userHelper.userHasPermission(regDto.registration(), CRUD.UPDATE);
- Map<VersionableEntity,TypeDesignationWorkingSet> typeDesignationworkingSets = regDto.getOrderedTypeDesignationWorkingSets();
+ Map<VersionableEntity,TypeDesignationSet> typeDesignationSets = regDto.getOrderedTypeDesignationSets();
- if(typeDesignationworkingSets != null){
- // order the typeDesignationworkingSet keys so that holotypes come first, etc
+ if(typeDesignationSets != null){
+ // order the typeDesignationSet keys so that holotypes come first, etc
List<TypedEntityRefWithStatus> baseRefsByHighestStatus = new ArrayList<>();
- for(VersionableEntity baseEntityRef : typeDesignationworkingSets.keySet()) {
- baseRefsByHighestStatus.add(new TypedEntityRefWithStatus(baseEntityRef, typeDesignationworkingSets.get(baseEntityRef).highestTypeStatus(new TypeDesignationStatusBaseComparator())));
+ for(VersionableEntity baseEntityRef : typeDesignationSets.keySet()) {
+ baseRefsByHighestStatus.add(new TypedEntityRefWithStatus(baseEntityRef, typeDesignationSets.get(baseEntityRef).highestTypeStatus(new TypeDesignationStatusBaseComparator())));
}
Collections.sort(baseRefsByHighestStatus);
for(TypedEntityRefWithStatus typedEntityRefWithStatus : baseRefsByHighestStatus) {
VersionableEntity baseEntity = typedEntityRefWithStatus.typedEntity;
- TypeDesignationWorkingSet typeDesignationWorkingSet = typeDesignationworkingSets.get(baseEntity);
- if (logger.isDebugEnabled()) {logger.debug("WorkingSet:" + typeDesignationWorkingSet.getWorkingsetType() + ">" + typeDesignationWorkingSet.getBaseEntity().toString());}
+ TypeDesignationSet typeDesignationSet = typeDesignationSets.get(baseEntity);
+ if (logger.isDebugEnabled()) {logger.debug("WorkingSet:" + typeDesignationSet.getWorkingsetType() + ">" + typeDesignationSet.getBaseEntity().toString());}
String buttonLabel = SpecimenOrObservationBase.class.isAssignableFrom(baseEntity.getClass()) ? "Type": "NameType";
Button tdButton = new Button(buttonLabel + ":");
tdButton.setDescription("Edit the type designation working set");
PermissionDebugUtils.addGainPerEntityPermissionButton(this, SpecimenOrObservationBase.class,
baseEntity.getUuid(), EnumSet.of(CRUD.UPDATE, CRUD.DELETE), RegistrationStatus.PREPARATION.name());
- typeDesignationButtons.add(new TypeDesignationWorkingSetButton(
- typeDesignationWorkingSet.getWorkingsetType(),
- typeDesignationWorkingSet.getBaseEntity(),
+ typeDesignationButtons.add(new TypeDesignationSetButton(
+ typeDesignationSet.getWorkingsetType(),
+ typeDesignationSet.getBaseEntity(),
tdButton)
);
String labelText = "<span class=\"field-unit-label\">" + TypeDesignationSetFormatter.entityLabel(baseEntity) + "</span>"; // renders the FieldUnit label
- for(TypeDesignationStatusBase<?> typeStatus : typeDesignationWorkingSet.keySet()){
- Collection<TypeDesignationDTO> tdPerStatus = typeDesignationWorkingSet.get(typeStatus);
+ for(TypeDesignationStatusBase<?> typeStatus : typeDesignationSet.keySet()){
+ Collection<TypeDesignationDTO> tdPerStatus = typeDesignationSet.get(typeStatus);
labelText += " <strong>" + typeStatus.getLabel() + (tdPerStatus.size() > 1 ? "s":"" ) + "</strong>: ";
boolean isFirst = true;
for(TypeDesignationDTO<?> dtDTO : tdPerStatus) {
return nameIdButton;
}
- public List<TypeDesignationWorkingSetButton> getTypeDesignationButtons() {
+ public List<TypeDesignationSetButton> getTypeDesignationButtons() {
return typeDesignationButtons;
}
addTypeDesignationButton.addStyleName(DEFAULT_BUTTON_STYLES);
}
- public class TypeDesignationWorkingSetButton {
+ public class TypeDesignationSetButton {
private VersionableEntity baseEntity;
- private TypeDesignationWorkingSetType type;
+ private TypeDesignationSetType type;
private Button button;
- public TypeDesignationWorkingSetButton(TypeDesignationWorkingSetType type, VersionableEntity baseEntity, Button button){
+ public TypeDesignationSetButton(TypeDesignationSetType type, VersionableEntity baseEntity, Button button){
this.type = type;
this.baseEntity = baseEntity;
this.button = button;
return button;
}
- public TypeDesignationWorkingSetType getType() {
+ public TypeDesignationSetType getType() {
return type;
}
}
import com.vaadin.ui.Button;
import com.vaadin.ui.Field;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.name.Registration;
import eu.etaxonomy.cdm.ref.TypedEntityReference;
/**
* @author a.kohlbecker
* @since Mar 22, 2017
- *
*/
-public class TypeDesignationWorkingsetEditorAction extends AbstractEditorAction<TypeDesignationWorkingSet> {
+public class TypeDesignationSetEditorAction extends AbstractEditorAction<TypeDesignationSet> {
- private TypeDesignationWorkingSetType workingSetType;
+ private TypeDesignationSetType workingSetType;
private UUID registrationUuid;
/**
* Constructor for {@link EditorActionType#EDIT EDIT} actions
*/
- public TypeDesignationWorkingsetEditorAction(VersionableEntity baseEntity,
- TypeDesignationWorkingSetType workingSetType,
+ public TypeDesignationSetEditorAction(VersionableEntity baseEntity,
+ TypeDesignationSetType workingSetType,
UUID registrationUuid, UUID typifiedNameUuid,
- Button source, Field<TypeDesignationWorkingSet> target, AbstractView sourceView, Stack<EditorActionContext> context) {
+ Button source, Field<TypeDesignationSet> target, AbstractView sourceView, Stack<EditorActionContext> context) {
super(EditorActionType.EDIT, null, source, target, sourceView);
this.baseEntity = baseEntity;
* @param source
* @param sourceView
*/
- public TypeDesignationWorkingsetEditorAction(TypeDesignationWorkingSetType workingSetType,
+ public TypeDesignationSetEditorAction(TypeDesignationSetType workingSetType,
UUID registrationUuid, UUID typifiedNameUuid,
- Button source, Field<TypeDesignationWorkingSet> target, AbstractView sourceView) {
+ Button source, Field<TypeDesignationSet> target, AbstractView sourceView) {
super(EditorActionType.ADD, null, source, target, sourceView);
this.workingSetType = workingSetType;
this.context.push(new EditorActionContext(new TypedEntityReference<Registration>(Registration.class, registrationUuid), sourceView));
}
- public TypeDesignationWorkingSetType getWorkingSetType() {
+ public TypeDesignationSetType getWorkingSetType() {
return workingSetType;
}
return registrationUuid;
}
- public UUID getTypeDesignationWorkingsetUuid(){
+ public UUID getTypeDesignationSetUuid(){
return getEntityUuid();
}
import eu.etaxonomy.cdm.model.term.DefinedTerm;
/**
- * A DTO which is use in the context of the {@link SpecimenTypeDesignationWorkingSetDTO} which is backed up
+ * A DTO which is use in the context of the {@link SpecimenTypeDesignationSetDTO} which is backed up
* <code>SpecimenTypeDesignation.typeSpecimen.derivedFrom.type</code> object graph.
* <p>
* The contained {@link DerivedUnit} either is a {@link MediaSpecimen} with or a {@link DerivedUnit}, depending on the
* @since Jun 16, 2017
*
*/
-public class SpecimenTypeDesignationWorkingSetDTO<OWNER extends VersionableEntity> {
+public class SpecimenTypeDesignationSetDTO<OWNER extends VersionableEntity> {
FieldUnit fieldUnit;
* @param baseEntity
* @param specimenTypeDesignations can be <code>null</code>
*/
- public SpecimenTypeDesignationWorkingSetDTO(OWNER owner, VersionableEntity baseEntity, List<SpecimenTypeDesignation> specimenTypeDesignations, TaxonName typifiedName) {
+ public SpecimenTypeDesignationSetDTO(OWNER owner, VersionableEntity baseEntity, List<SpecimenTypeDesignation> specimenTypeDesignations, TaxonName typifiedName) {
super();
this.owner = owner;
this.baseEntity = baseEntity;
* @param citationEntityID
* @param typifiedNameEntityID
*/
- public SpecimenTypeDesignationWorkingSetDTO(OWNER reg, FieldUnit newfieldUnit, TaxonName typifiedName) {
+ public SpecimenTypeDesignationSetDTO(OWNER reg, FieldUnit newfieldUnit, TaxonName typifiedName) {
this(reg, newfieldUnit, null, typifiedName);
}
/**
*
- * @return the set of SpecimenTypeDesignation that haven been deleted from the <code>SpecimenTypeDesignationWorkingSetDTO</code>.
+ * @return the set of SpecimenTypeDesignation that haven been deleted from the {@link SpecimenTypeDesignationSetDTO}.
*/
public Set<SpecimenTypeDesignation> deletedSpecimenTypeDesignations() {
Set<SpecimenTypeDesignation> deletedEntities = new HashSet<>(specimenTypeDesignationsLoaded);
private static final long serialVersionUID = 896305051895903033L;
- public static final Logger logger = Logger.getLogger(SpecimenTypeDesignationWorkingsetEditorPresenter.class);
+ public static final Logger logger = Logger.getLogger(NameTypeDesignationPresenter.class);
private HashSet<TaxonName> typifiedNamesAsLoaded;
protected NameTypeDesignation loadBeanById(Object identifier) {
NameTypeDesignation bean;
- NameTypeDesignationWorkingsetIds idset = (NameTypeDesignationWorkingsetIds)identifier;
+ NameTypeDesignationSetIds idset = (NameTypeDesignationSetIds)identifier;
if(idset.isForNewTypeDesignation()) {
Reference reference = getRepo().getReferenceService().load(idset.getPublishedUnitUuid());
try {
setPublishedUnit(NamedSource.NewPrimarySourceInstance(reference, null));
} catch(Exception e) {
- throw new RuntimeException("Reference of invalid type passed via NameTypeDesignationWorkingsetIds as publishedUnitUuid ", e);
+ throw new RuntimeException("Reference of invalid type passed via NameTypeDesignationSetIds as publishedUnitUuid ", e);
}
EntityInitStrategy initstrategy = RegistrationWorkingSetService.NAME_INIT_STRATEGY
.clone()
bean = super.loadBeanById(idset.getBaseEntity().getUuid());
// TODO prevent from errors due to inconsistent data, two options:
// 1. handle error condition here
- // 2. always set typifiedNameUuid in NameTypeDesignationWorkingsetIds
+ // 2. always set typifiedNameUuid in NameTypeDesignationSetIds
typifiedNameInContext = bean.getTypifiedNames().iterator().next();
try {
setPublishedUnit(bean.getTypifiedNames().iterator().next().getNomenclaturalSource());
* @author a.kohlbecker
* @since Jan 20, 2021
*/
-public class NameTypeDesignationWorkingsetIds extends TypeDesignationWorkingsetIds<NameTypeDesignation> {
+public class NameTypeDesignationSetIds extends TypeDesignationSetIds<NameTypeDesignation> {
- public static NameTypeDesignationWorkingsetIds forNewTypeDesignation(UUID publishedUnitUuid, UUID typifiedNameUuid) {
- return new NameTypeDesignationWorkingsetIds(publishedUnitUuid, typifiedNameUuid);
+ public static NameTypeDesignationSetIds forNewTypeDesignation(UUID publishedUnitUuid, UUID typifiedNameUuid) {
+ return new NameTypeDesignationSetIds(publishedUnitUuid, typifiedNameUuid);
}
public static Object forExistingTypeDesignation(UUID publishedUnitUuid, NameTypeDesignation baseEntity) {
- return new NameTypeDesignationWorkingsetIds(publishedUnitUuid, baseEntity);
+ return new NameTypeDesignationSetIds(publishedUnitUuid, baseEntity);
}
- private NameTypeDesignationWorkingsetIds(UUID publishedUnitUuid, NameTypeDesignation baseEntity) {
+ private NameTypeDesignationSetIds(UUID publishedUnitUuid, NameTypeDesignation baseEntity) {
super(publishedUnitUuid, null, baseEntity, null);
}
- private NameTypeDesignationWorkingsetIds(UUID publishedUnitUuid, UUID typifiedNameUuid) {
+ private NameTypeDesignationSetIds(UUID publishedUnitUuid, UUID typifiedNameUuid) {
super(publishedUnitUuid, null, null, typifiedNameUuid);
}
/**
* CollectionRow for {@link SpecimenTypeDesignationDTO}
* SpecimenTypeDesignationDTORow needs to be instantiated by a EditorInstantiator which can only be provided by the presenter
- * {@link SpecimenTypeDesignationWorkingsetEditorPresenter#handleViewEntered()}
+ * {@link SpecimenTypeDesignationSetEditorPresenter#handleViewEntered()}
*
* @author a.kohlbecker
* @since Jun 22, 2017
import org.apache.log4j.Logger;
import org.hibernate.criterion.Restrictions;
-import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.vaadin.spring.events.annotation.EventBusListenerMethod;
import eu.etaxonomy.cdm.service.CdmBeanItemContainerFactory;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
import eu.etaxonomy.cdm.service.CdmFilterablePagingProviderFactory;
-import eu.etaxonomy.cdm.service.ISpecimenTypeDesignationWorkingSetService;
+import eu.etaxonomy.cdm.service.ISpecimenTypeDesignationSetService;
import eu.etaxonomy.cdm.service.UserHelperAccess;
import eu.etaxonomy.cdm.service.initstrategies.AgentBaseInit;
import eu.etaxonomy.cdm.vaadin.component.CollectionRowItemCollection;
import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;
import eu.etaxonomy.cdm.vaadin.model.registration.RegistrationTermLists;
import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;
-import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationWorkingSetDTO;
+import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationSetDTO;
import eu.etaxonomy.cdm.vaadin.ui.RegistrationUIDefaults;
import eu.etaxonomy.cdm.vaadin.util.CollectionCaptionGenerator;
import eu.etaxonomy.cdm.vaadin.util.ReferenceEllypsisCaptionGenerator;
import eu.etaxonomy.vaadin.mvp.AbstractView;
import eu.etaxonomy.vaadin.mvp.BeanInstantiator;
/**
- * SpecimenTypeDesignationWorkingsetPopupEditorView implementation must override the showInEditor() method,
+ * SpecimenTypeDesignationSetPopupEditorView implementation must override the showInEditor() method,
* see {@link #prepareAsFieldGroupDataSource()} for details.
*
* @author a.kohlbecker
*/
@SpringComponent
@Scope("prototype")
-public class SpecimenTypeDesignationWorkingsetEditorPresenter
- extends AbstractEditorPresenter<SpecimenTypeDesignationWorkingSetDTO , SpecimenTypeDesignationWorkingsetPopupEditorView>
- implements CachingPresenter, NomenclaturalActContext, DisposableBean {
+public class SpecimenTypeDesignationSetEditorPresenter
+ extends AbstractEditorPresenter<SpecimenTypeDesignationSetDTO,SpecimenTypeDesignationSetPopupEditorView>
+ implements CachingPresenter, NomenclaturalActContext {
private static final long serialVersionUID = 4255636253714476918L;
- public static final Logger logger = Logger.getLogger(SpecimenTypeDesignationWorkingsetEditorPresenter.class);
+ public static final Logger logger = Logger.getLogger(SpecimenTypeDesignationSetEditorPresenter.class);
private static final EnumSet<CRUD> COLLECTION_EDITOR_CRUD = EnumSet.of(CRUD.UPDATE, CRUD.DELETE);
-
/**
* This object for this field will either be injected by the {@link PopupEditorFactory} or by a Spring
* {@link BeanFactory}
*/
@Autowired
- private ISpecimenTypeDesignationWorkingSetService specimenTypeDesignationWorkingSetService;
+ private ISpecimenTypeDesignationSetService specimenTypeDesignationSetService;
@Autowired
- protected CdmFilterablePagingProviderFactory pagingProviderFactory;
+ private CdmFilterablePagingProviderFactory pagingProviderFactory;
@Autowired
- protected CdmBeanItemContainerFactory cdmBeanItemContainerFactory;
+ private CdmBeanItemContainerFactory cdmBeanItemContainerFactory;
/**
* if not null, this CRUD set is to be used to create a CdmAuthoritiy for the base entitiy which will be
private ICdmEntityUuidCacher cache;
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingSetDto;
+ private SpecimenTypeDesignationSetDTO<Registration> workingSetDto;
- CdmFilterablePagingProvider<Reference, Reference> designationReferencePagingProvider;
+ private CdmFilterablePagingProvider<Reference, Reference> designationReferencePagingProvider;
- CdmFilterablePagingProvider<Reference, Reference> mediaReferencePagingProvider;
+ private CdmFilterablePagingProvider<Reference, Reference> mediaReferencePagingProvider;
/**
* The unit of publication in which the type designation has been published.
* loading the Registration specified by the <code>RegistrationAndWorkingsetId.registrationId</code> and in
* a second step to find the workingset by the <code>registrationAndWorkingsetId.workingsetId</code>.
* <p>
- * The <code>identifier</code> must be of the type {@link TypeDesignationWorkingsetIds} whereas the
+ * The <code>identifier</code> must be of the type {@link TypeDesignationSetIds} whereas the
* field <code>registrationId</code> must be present.
* The field <code>workingsetId</code> however can be null.
* I this case a new workingset with a new {@link FieldUnit} as
* base entity is being created.
*
- * @param identifier a {@link TypeDesignationWorkingsetIds}
+ * @param identifier a {@link TypeDesignationSetIds}
*/
@Override
- protected SpecimenTypeDesignationWorkingSetDTO<Registration> loadBeanById(Object identifier) {
+ protected SpecimenTypeDesignationSetDTO<Registration> loadBeanById(Object identifier) {
cache = new CdmTransientEntityAndUuidCacher(this);
if(identifier != null){
- SpecimenTypeDesignationWorkingsetIds idset = (SpecimenTypeDesignationWorkingsetIds)identifier;
+ SpecimenTypeDesignationSetIds idset = (SpecimenTypeDesignationSetIds)identifier;
if(idset.baseEntity != null){
// load existing workingset
- workingSetDto = specimenTypeDesignationWorkingSetService.load(idset.registrationUuid, idset.baseEntity);
+ workingSetDto = specimenTypeDesignationSetService.load(idset.registrationUuid, idset.baseEntity);
if(workingSetDto.getFieldUnit() == null){
- workingSetDto = specimenTypeDesignationWorkingSetService.fixMissingFieldUnit(workingSetDto);
+ workingSetDto = specimenTypeDesignationSetService.fixMissingFieldUnit(workingSetDto);
// FIXME open Dialog to warn user about adding an empty fieldUnit to the typeDesignations
// This method must go again into the presenter !!!!
logger.info("Basing all typeDesignations on a new fieldUnit");
}
} else {
// create a new workingset, for a new fieldunit which is the base for the workingset
- workingSetDto = specimenTypeDesignationWorkingSetService.create(idset.getRegistrationUUID(), idset.getTypifiedNameUuid());
+ workingSetDto = specimenTypeDesignationSetService.create(idset.getRegistrationUUID(), idset.getTypifiedNameUuid());
cache.load(workingSetDto.getTypifiedName());
rootEntities.add(workingSetDto.getTypifiedName());
}
);
row.collection.getSelect().setCaptionGenerator(new CollectionCaptionGenerator());
row.collection.getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Collection>(row.collection.getSelect(),
- SpecimenTypeDesignationWorkingsetEditorPresenter.this));
+ SpecimenTypeDesignationSetEditorPresenter.this));
row.collection.addClickListenerAddEntity(e -> doCollectionEditorAdd(row));
row.collection.addClickListenerEditEntity(e -> {
if(row.collection.getValue() != null){
);
row.designationReference.getSelect().setCaptionGenerator(new ReferenceEllypsisCaptionGenerator(LabelType.BIBLIOGRAPHIC, row.designationReference.getSelect()));
row.designationReference.getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Reference>(row.designationReference.getSelect(),
- SpecimenTypeDesignationWorkingsetEditorPresenter.this));
+ SpecimenTypeDesignationSetEditorPresenter.this));
row.designationReference.addClickListenerAddEntity(e -> doReferenceEditorAdd(row.designationReference));
row.designationReference.addClickListenerEditEntity(e -> {
if(row.designationReference.getValue() != null){
);
row.mediaSpecimenReference.getSelect().setCaptionGenerator(new ReferenceEllypsisCaptionGenerator(LabelType.BIBLIOGRAPHIC, row.mediaSpecimenReference.getSelect()));
row.mediaSpecimenReference.getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Reference>(row.mediaSpecimenReference.getSelect(),
- SpecimenTypeDesignationWorkingsetEditorPresenter.this));
+ SpecimenTypeDesignationSetEditorPresenter.this));
row.mediaSpecimenReference.addClickListenerAddEntity(e -> doReferenceEditorAdd(row.mediaSpecimenReference));
row.mediaSpecimenReference.addClickListenerEditEntity(e -> {
if(row.mediaSpecimenReference.getValue() != null){
* {@inheritDoc}
*/
@Override
- protected void saveBean(SpecimenTypeDesignationWorkingSetDTO dto) {
+ protected void saveBean(SpecimenTypeDesignationSetDTO dto) {
if(crud != null){
UserHelperAccess.userHelper().createAuthorityForCurrentUser(dto.getFieldUnit(), crud, null);
}
}
- specimenTypeDesignationWorkingSetService.save(dto);
+ specimenTypeDesignationSetService.save(dto);
}
/**
* {@inheritDoc}
*/
@Override
- protected void deleteBean(SpecimenTypeDesignationWorkingSetDTO bean) {
- specimenTypeDesignationWorkingSetService.delete(bean, true);
+ protected void deleteBean(SpecimenTypeDesignationSetDTO bean) {
+ specimenTypeDesignationSetService.delete(bean, true);
}
/**
/**
* In this method the SpecimenTypeDesignation is dissociated from the Registration.
- * The actual deletion of the SpecimenTypeDesignation and DerivedUnit will take place in {@link #saveBean(SpecimenTypeDesignationWorkingSetDTO)}
+ * The actual deletion of the SpecimenTypeDesignation and DerivedUnit will take place in {@link #saveBean(SpecimenTypeDesignationSetDTO)}
*
* TODO once https://dev.e-taxonomy.eu/redmine/issues/7077 is fixed dissociating from the Registration could be removed here
*
* @author a.kohlbecker
* @since Jan 20, 2021
*/
-public class SpecimenTypeDesignationWorkingsetIds extends TypeDesignationWorkingsetIds<FieldUnit> {
+public class SpecimenTypeDesignationSetIds extends TypeDesignationSetIds<FieldUnit> {
- public SpecimenTypeDesignationWorkingsetIds(UUID publishedUnitUuid, UUID registrationUuid,
+ public SpecimenTypeDesignationSetIds(UUID publishedUnitUuid, UUID registrationUuid,
FieldUnit baseEntity, UUID typifiedNameUuid) {
super(publishedUnitUuid, registrationUuid, baseEntity, typifiedNameUuid);
import eu.etaxonomy.cdm.vaadin.component.common.TeamOrPersonField;
import eu.etaxonomy.cdm.vaadin.component.common.TimePeriodField;
import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;
-import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationWorkingSetDTO;
+import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationSetDTO;
import eu.etaxonomy.cdm.vaadin.permission.AccessRestrictedView;
import eu.etaxonomy.cdm.vaadin.permission.RolesAndPermissions;
import eu.etaxonomy.cdm.vaadin.ui.RegistrationUIDefaults;
* @since May 15, 2017
*
* TODO as subclass of AbstractCdmPopupEditor?
- *
*/
@SpringComponent
@Scope("prototype")
-public class SpecimenTypeDesignationWorkingsetPopupEditor
- extends AbstractPopupEditor<SpecimenTypeDesignationWorkingSetDTO, SpecimenTypeDesignationWorkingsetEditorPresenter>
- implements SpecimenTypeDesignationWorkingsetPopupEditorView, AccessRestrictedView, PerEntityAuthorityGrantingEditor {
+public class SpecimenTypeDesignationSetPopupEditor
+ extends AbstractPopupEditor<SpecimenTypeDesignationSetDTO, SpecimenTypeDesignationSetEditorPresenter>
+ implements SpecimenTypeDesignationSetPopupEditorView, AccessRestrictedView, PerEntityAuthorityGrantingEditor {
private static final String CAN_T_SAVE_AS_LONG_AS_TYPE_DESIGNATIONS_ARE_MISSING = "Can't save as long as type designations are missing.";
- /**
- * @param layout
- * @param dtoType
- */
- public SpecimenTypeDesignationWorkingsetPopupEditor() {
- super(new GridLayout(), SpecimenTypeDesignationWorkingSetDTO.class);
+ public SpecimenTypeDesignationSetPopupEditor() {
+ super(new GridLayout(), SpecimenTypeDesignationSetDTO.class);
GridLayout grid = (GridLayout) getFieldLayout();
grid.setMargin(true);
grid.setSpacing(true);
private ElementCollectionField<SpecimenTypeDesignationDTO> typeDesignationsCollectionField;
- private EnumSet<CRUD> crud;
-
private TeamOrPersonField collectorField;
private FilterableAnnotationsField annotationsListField;
}
- // ------- SpecimenTypeDesignationWorkingsetPopupEditorView methods ---- //
+ // ------- SpecimenTypeDesignationSetPopupEditorView methods ---- //
@Override
public ElementCollectionField<SpecimenTypeDesignationDTO> getTypeDesignationsCollectionField() {
return typeDesignationsCollectionField;
public void updateAllowDeleteTypeDesignation(){
// disable the delete button if there is only one typeDesignation
// if this typeDesignation is deleted the fieldUnit would become orphan in the
- // TypeDesignationWorkingSet
+ // TypeDesignationSet
GridLayout gridLayout = this.typeDesignationsCollectionField.getLayout();
if(gridLayout.getRows() == 3){ // first row is header, last row is next new item
gridLayout.getComponent(gridLayout.getColumns() - 1, 1).setEnabled(false);
* @since Jun 13, 2017
*
*/
-public interface SpecimenTypeDesignationWorkingsetPopupEditorView extends ApplicationView<SpecimenTypeDesignationWorkingsetEditorPresenter>,
- AnnotationsEditor {
+public interface SpecimenTypeDesignationSetPopupEditorView
+ extends ApplicationView<SpecimenTypeDesignationSetEditorPresenter>,
+ AnnotationsEditor {
public NativeSelect getCountrySelectField();
/**
* Disable the delete button if there is only one typeDesignation
* if this typeDesignation is deleted the fieldUnit would become orphan in the
- * TypeDesignationWorkingSet
+ * TypeDesignationSet
*/
public void updateAllowDeleteTypeDesignation();
import eu.etaxonomy.cdm.model.common.VersionableEntity;
-public abstract class TypeDesignationWorkingsetIds<BASE_T extends VersionableEntity> {
+public abstract class TypeDesignationSetIds<BASE_T extends VersionableEntity> {
protected UUID registrationUuid;
protected BASE_T baseEntity;
*/
protected UUID publishedUnitUuid;
- protected TypeDesignationWorkingsetIds(UUID publishedUnitUuid, UUID registrationUuid, BASE_T baseEntity, UUID typifiedNameUuid) {
+ protected TypeDesignationSetIds(UUID publishedUnitUuid, UUID registrationUuid, BASE_T baseEntity, UUID typifiedNameUuid) {
this.publishedUnitUuid = publishedUnitUuid;
this.registrationUuid = registrationUuid;
this.baseEntity = baseEntity;
import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;
import eu.etaxonomy.cdm.api.service.dto.RegistrationWorkingSet;
import eu.etaxonomy.cdm.api.service.exception.RegistrationValidationException;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.api.service.registration.IRegistrationWorkingSetService;
import eu.etaxonomy.cdm.api.util.UserHelper;
import eu.etaxonomy.cdm.cache.CdmTransientEntityAndUuidCacher;
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEventEntityTypeFilter;
import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
-import eu.etaxonomy.cdm.vaadin.event.TypeDesignationWorkingsetEditorAction;
+import eu.etaxonomy.cdm.vaadin.event.TypeDesignationSetEditorAction;
import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction;
import eu.etaxonomy.cdm.vaadin.ui.RegistrationUIDefaults;
import eu.etaxonomy.cdm.vaadin.ui.config.TaxonNamePopupEditorConfig;
import eu.etaxonomy.cdm.vaadin.util.CdmTitleCacheCaptionGenerator;
import eu.etaxonomy.cdm.vaadin.view.name.CachingPresenter;
import eu.etaxonomy.cdm.vaadin.view.name.NameTypeDesignationPopupEditor;
-import eu.etaxonomy.cdm.vaadin.view.name.NameTypeDesignationWorkingsetIds;
-import eu.etaxonomy.cdm.vaadin.view.name.SpecimenTypeDesignationWorkingsetIds;
-import eu.etaxonomy.cdm.vaadin.view.name.SpecimenTypeDesignationWorkingsetPopupEditor;
+import eu.etaxonomy.cdm.vaadin.view.name.NameTypeDesignationSetIds;
+import eu.etaxonomy.cdm.vaadin.view.name.SpecimenTypeDesignationSetIds;
+import eu.etaxonomy.cdm.vaadin.view.name.SpecimenTypeDesignationSetPopupEditor;
import eu.etaxonomy.cdm.vaadin.view.name.TaxonNameEditorPresenter;
import eu.etaxonomy.cdm.vaadin.view.name.TaxonNamePopupEditor;
import eu.etaxonomy.cdm.vaadin.view.name.TaxonNamePopupEditorMode;
}
@EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
- public void onTypeDesignationsEditorActionEdit(TypeDesignationWorkingsetEditorAction event) {
+ public void onTypeDesignationsEditorActionEdit(TypeDesignationSetEditorAction event) {
if(!checkFromOwnView(event)){
return;
RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();
- if(event.getWorkingSetType() == TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET ){
- SpecimenTypeDesignationWorkingsetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationWorkingsetPopupEditor.class, event);
+ if(event.getWorkingSetType() == TypeDesignationSetType.SPECIMEN_TYPE_DESIGNATION_SET ){
+ SpecimenTypeDesignationSetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationSetPopupEditor.class, event);
popup.setParentEditorActionContext(event.getContext(), event.getTarget());
popup.withDeleteButton(true);
- popup.loadInEditor(new SpecimenTypeDesignationWorkingsetIds(
+ popup.loadInEditor(new SpecimenTypeDesignationSetIds(
workingset.getCitationUuid(),
event.getRegistrationUuid(),
CdmBase.deproxy(event.getBaseEntity(), FieldUnit.class), null));
NameTypeDesignationPopupEditor popup = openPopupEditor(NameTypeDesignationPopupEditor.class, event);
popup.setParentEditorActionContext(event.getContext(), event.getTarget());
popup.withDeleteButton(true);
- popup.loadInEditor(NameTypeDesignationWorkingsetIds.forExistingTypeDesignation(
+ popup.loadInEditor(NameTypeDesignationSetIds.forExistingTypeDesignation(
registrationDTO.getCitationUuid(),
CdmBase.deproxy(event.getBaseEntity(), NameTypeDesignation.class))
);
}
@EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
- public void onTypeDesignationWorkingsetAdd(TypeDesignationWorkingsetEditorAction event) {
+ public void onTypeDesignationSetAdd(TypeDesignationSetEditorAction event) {
if(!event.hasSource()){
return;
RegistrationDTO registrationDTO = workingset.getRegistrationDTO(event.getRegistrationUuid()).get();
- if(event.getWorkingSetType() == TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET){
- SpecimenTypeDesignationWorkingsetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationWorkingsetPopupEditor.class, event);
+ if(event.getWorkingSetType() == TypeDesignationSetType.SPECIMEN_TYPE_DESIGNATION_SET){
+ SpecimenTypeDesignationSetPopupEditor popup = openPopupEditor(SpecimenTypeDesignationSetPopupEditor.class, event);
popup.setParentEditorActionContext(event.getContext(), event.getTarget());
TypedEntityReference<TaxonName> typifiedNameRef;
if(registrationDTO.getTypifiedNameRef() != null){
popup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));
popup.withDeleteButton(false);
- popup.loadInEditor(new SpecimenTypeDesignationWorkingsetIds(
+ popup.loadInEditor(new SpecimenTypeDesignationSetIds(
workingset.getCitationUuid(),
event.getRegistrationUuid(),
null,
}
});
popup.withDeleteButton(false);
- popup.loadInEditor(NameTypeDesignationWorkingsetIds.forNewTypeDesignation(
+ popup.loadInEditor(NameTypeDesignationSetIds.forNewTypeDesignation(
registrationDTO.getCitationUuid(),
event.getTypifiedNameUuid()
)
return;
}
- if(event.getPopup() instanceof SpecimenTypeDesignationWorkingsetPopupEditor){
+ if(event.getPopup() instanceof SpecimenTypeDesignationSetPopupEditor){
if(event.getReason().equals(Reason.SAVE)){
// NOTE: adding the SpecimenTypeDesignations to the registration is done in the
- // SpecimenTypeDesignationWorkingSetServiceImpl.save(SpecimenTypeDesignationWorkingSetDTO dto) method
+ // SpecimenTypeDesignationSetServiceImpl.save(SpecimenTypeDesignationSetDTO dto) method
}
// always reload if the first editor is closed as the data might have been changed through any other sub-popupeditor
refreshView(isAtContextRoot(event.getPopup()));
UUID getCitationUuid();
/**
- * selecting a type will cause a {@link TypeDesignationWorkingsetEditorAction} to be emitted.
+ * selecting a type will cause a {@link TypeDesignationSetEditorAction} to be emitted.
* On Cancel .. TODO
* @param registrationEntityUuid
*/
import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;
import eu.etaxonomy.cdm.api.service.dto.RegistrationType;
import eu.etaxonomy.cdm.api.service.dto.RegistrationWorkingSet;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet.TypeDesignationWorkingSetType;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
import eu.etaxonomy.cdm.api.util.RoleProberImpl;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.name.Registration;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItem;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemButtons;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemNameAndTypeButtons;
-import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemNameAndTypeButtons.TypeDesignationWorkingSetButton;
+import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemNameAndTypeButtons.TypeDesignationSetButton;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemsPanel;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationStatusFieldInstantiator;
import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationStatusLabel;
import eu.etaxonomy.cdm.vaadin.event.RegistrationEditorAction;
import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
-import eu.etaxonomy.cdm.vaadin.event.TypeDesignationWorkingsetEditorAction;
+import eu.etaxonomy.cdm.vaadin.event.TypeDesignationSetEditorAction;
import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction;
import eu.etaxonomy.cdm.vaadin.permission.AccessRestrictedView;
import eu.etaxonomy.cdm.vaadin.permission.PermissionDebugUtils;
});
}
- for(TypeDesignationWorkingSetButton workingsetButton : regItemButtonGroup.getTypeDesignationButtons()){
+ for(TypeDesignationSetButton workingsetButton : regItemButtonGroup.getTypeDesignationButtons()){
workingsetButton.getButton().addClickListener(e -> {
VersionableEntity baseEntity = workingsetButton.getBaseEntity();
EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);
- TypeDesignationWorkingSetType workingsetType = workingsetButton.getType();
- getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(
+ TypeDesignationSetType workingsetType = workingsetButton.getType();
+ getViewEventBus().publish(this, new TypeDesignationSetEditorAction(
baseEntity,
workingsetType,
registrationEntityUuid,
typeDesignationTypeCooser.setCaption("Add new type designation");
Label label = new Label("Please select kind of type designation to be created.");
Button newSpecimenTypeDesignationButton = new Button("Specimen type designation",
- e -> addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType.SPECIMEN_TYPE_DESIGNATION_WORKINGSET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
+ e -> addNewTypeDesignationSet(TypeDesignationSetType.SPECIMEN_TYPE_DESIGNATION_SET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
Button newNameTypeDesignationButton = new Button("Name type designation",
- e -> addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType.NAME_TYPE_DESIGNATION_WORKINGSET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
+ e -> addNewTypeDesignationSet(TypeDesignationSetType.NAME_TYPE_DESIGNATION_SET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
VerticalLayout layout = new VerticalLayout(label, newSpecimenTypeDesignationButton, newNameTypeDesignationButton);
layout.setMargin(true);
* @param button
*
*/
- protected void addNewTypeDesignationWorkingset(TypeDesignationWorkingSetType newWorkingsetType, UUID registrationEntityUuid, Window typeDesignationTypeCooser, Button sourceButton) {
+ protected void addNewTypeDesignationSet(TypeDesignationSetType newWorkingsetType, UUID registrationEntityUuid, Window typeDesignationTypeCooser, Button sourceButton) {
UI.getCurrent().removeWindow(typeDesignationTypeCooser);
EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);
- getViewEventBus().publish(this, new TypeDesignationWorkingsetEditorAction(
+ getViewEventBus().publish(this, new TypeDesignationSetEditorAction(
newWorkingsetType,
registrationEntityUuid,
typifiedNameRef.getUuid(),
import eu.etaxonomy.cdm.model.term.DefinedTerm;
import eu.etaxonomy.cdm.vaadin.model.registration.KindOfUnitTerms;
import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationDTO;
-import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationWorkingSetDTO;
+import eu.etaxonomy.cdm.vaadin.model.registration.SpecimenTypeDesignationSetDTO;
/**
* @author a.kohlbecker
@Transactional(TransactionMode.DISABLED)
// IMPORTANT: test03_deleteTypeDesignationTest executed not as last would cause the other tests to fail due to changes in the db
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class SpecimenTypeDesignationWorkingSetServiceImplTest extends CdmVaadinIntegrationTest{
+public class SpecimenTypeDesignationSetServiceImplTest extends CdmVaadinIntegrationTest{
@SpringBeanByName
private CdmRepository cdmRepository;
@SpringBeanByType
- private ISpecimenTypeDesignationWorkingSetService service;
+ private ISpecimenTypeDesignationSetService service;
@SpringBeanByType
private IOccurrenceService occurrenceService;
};
@Test
- @DataSet("SpecimenTypeDesignationWorkingSetServiceImplTest.xml")
+ @DataSet("SpecimenTypeDesignationSetServiceImplTest.xml")
public void test01_createAndEditTest() throws DerivedUnitConversionException, URISyntaxException, FileNotFoundException {
// printDataSet(System.err, new String[]{"USERACCOUNT", "GROUPS", "USERACCOUNT_GRANTEDAUTHORITYIMPL", "USERACCOUNT_PERMISSIONGROUP"
// "REPRESENTATION", "REPRESENTATION_AUD", "HIBERNATE_SEQUENCES"},
// "RegistrationTerms");
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingset = service.create(registrationUuid, typifiedNameUuid);
+ SpecimenTypeDesignationSetDTO<Registration> workingset = service.create(registrationUuid, typifiedNameUuid);
Assert.assertNotNull(workingset.getOwner());
Assert.assertEquals(Registration.class, workingset.getOwner().getClass());
}
@Test
- @DataSet("SpecimenTypeDesignationWorkingSetServiceImplTest-deleteTest.xml")
- @ExpectedDataSet("SpecimenTypeDesignationWorkingSetServiceImplTest.deleteTypeDesignationTest-result.xml")
+ @DataSet("SpecimenTypeDesignationSetServiceImplTest-deleteTest.xml")
+ @ExpectedDataSet("SpecimenTypeDesignationSetServiceImplTest.deleteTypeDesignationTest-result.xml")
public void test03_deleteTypeDesignationTest() {
FieldUnit baseEntity = (FieldUnit)occurrenceService.load(fieldUnitUuid);
// FieldUnit" ID="5001
// TypedEntityReference<FieldUnit> baseEntityRef = new TypedEntityReference<>(FieldUnit.class, fieldUnitUuid, "Somewhere, FieldNumber.");
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingset = service.load(registrationUuid, baseEntity);
+ SpecimenTypeDesignationSetDTO<Registration> workingset = service.load(registrationUuid, baseEntity);
Assert.assertTrue(workingset.getSpecimenTypeDesignationDTOs().size() == 2);
SpecimenTypeDesignationDTO deleteDTO = null;
}
@Test
- @DataSet("SpecimenTypeDesignationWorkingSetServiceImplTest-deleteTest.xml")
+ @DataSet("SpecimenTypeDesignationSetServiceImplTest-deleteTest.xml")
public void test02_deleteWorkingset() {
// printDataSet(System.err, includeTableNames_delete);
// TypedEntityReference<FieldUnit> baseEntityRef = new TypedEntityReference<>(FieldUnit.class, fieldUnitUuid, null);
- SpecimenTypeDesignationWorkingSetDTO<Registration> workingset = service.load(registrationUuid, baseEntity);
+ SpecimenTypeDesignationSetDTO<Registration> workingset = service.load(registrationUuid, baseEntity);
Assert.assertNotNull(workingset.getOwner());
Assert.assertEquals(2, workingset.getSpecimenTypeDesignationDTOs().size());
service.delete(workingset, true);
BGBM BDI Projects / cdm-vaadin.git / commitdiff