From b9526c68790fd90acbcedfabfb2c02836f8ac1f2 Mon Sep 17 00:00:00 2001 From: Marcos Lopez Gonzalez Date: Wed, 5 May 2021 13:18:53 +0200 Subject: [PATCH] use of new interfaces for services --- .../it/collections/data/TestDataFactory.java | 2 + .../BaseCollectionEntityResourceIT.java | 48 +++++------- .../resource/CollectionResourceIT.java | 46 ++--------- .../resource/InstitutionResourceIT.java | 46 ++--------- .../resource/PersonResourceIT.java | 32 +------- .../PrimaryCollectionEntityResourceIT.java | 26 +++---- .../BaseCollectionEntityServiceIT.java | 71 ++++++++--------- .../it/collections/service/BaseServiceIT.java | 13 +--- .../service/CollectionServiceIT.java | 6 +- .../service/InstitutionServiceIT.java | 2 - .../PrimaryCollectionEntityServiceIT.java | 76 +++++++++---------- .../BaseCollectionEntityService.java | 13 +--- ...> BasePrimaryCollectionEntityService.java} | 7 +- .../collections/DefaultCollectionService.java | 2 +- .../DefaultInstitutionService.java | 2 +- .../collections/merge/BaseMergeService.java | 25 ++++-- .../BaseCollectionEntityResource.java | 55 +++++--------- .../collections/CollectionResource.java | 8 -- .../collections/InstitutionResource.java | 13 ---- .../resources/collections/PersonResource.java | 4 +- .../PrimaryCollectionEntityResource.java | 48 ++++-------- 21 files changed, 193 insertions(+), 352 deletions(-) rename registry-service/src/main/java/org/gbif/registry/service/collections/{PrimaryCollectionEntityService.java => BasePrimaryCollectionEntityService.java} (97%) diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/data/TestDataFactory.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/data/TestDataFactory.java index 29a7d30970..6f358d5531 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/data/TestDataFactory.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/data/TestDataFactory.java @@ -27,6 +27,8 @@ public static TestData create(Class clazz) { throw new UnsupportedOperationException(); } + // TODO: populate more fields + public static class CollectionTestData implements TestData { public static final String NAME = "name"; diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/BaseCollectionEntityResourceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/BaseCollectionEntityResourceIT.java index afbd6dd982..1112d5dd72 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/BaseCollectionEntityResourceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/BaseCollectionEntityResourceIT.java @@ -10,11 +10,7 @@ import org.gbif.api.model.registry.MachineTaggable; import org.gbif.api.model.registry.Tag; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.CrudService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.vocabulary.IdentifierType; import org.gbif.registry.search.test.EsManageServer; import org.gbif.registry.ws.client.collections.BaseCollectionEntityClient; @@ -77,7 +73,7 @@ public void crudTest() { T entity = testData.newEntity(); UUID entityKey = UUID.randomUUID(); - when(getMockCrudService().create(entity)).thenReturn(entityKey); + when(getMockBaseService().create(entity)).thenReturn(entityKey); UUID key = baseClient.create(entity); assertEquals(entityKey, key); @@ -88,7 +84,7 @@ public void crudTest() { // update entity = testData.updateEntity(entitySaved); - doNothing().when(getMockCrudService()).update(entity); + doNothing().when(getMockBaseService()).update(entity); baseClient.update(entity); mockGetEntity(entityKey, entity); @@ -96,7 +92,7 @@ public void crudTest() { assertTrue(entity.lenientEquals(entitySaved)); // delete - doNothing().when(getMockCrudService()).delete(key); + doNothing().when(getMockBaseService()).delete(key); baseClient.delete(key); entity.setDeleted(new Date()); @@ -176,19 +172,19 @@ public void tagsTest() { tag.setValue("value"); int tagKey = 1; - when(getMockTagService().addTag(key, tag)).thenReturn(tagKey); + when(getMockBaseService().addTag(key, tag)).thenReturn(tagKey); int returnedKey = baseClient.addTag(key, tag); assertEquals(tagKey, returnedKey); tag.setKey(returnedKey); - when(getMockTagService().listTags(key, null)).thenReturn(Collections.singletonList(tag)); + when(getMockBaseService().listTags(key, null)).thenReturn(Collections.singletonList(tag)); List tagsReturned = baseClient.listTags(key, null); assertEquals(1, tagsReturned.size()); assertEquals(tagKey, tagsReturned.get(0).getKey()); assertEquals("value", tagsReturned.get(0).getValue()); - doNothing().when(getMockTagService()).deleteTag(key, tagKey); + doNothing().when(getMockBaseService()).deleteTag(key, tagKey); assertDoesNotThrow(() -> baseClient.deleteTag(key, tagKey)); } @@ -197,20 +193,20 @@ public void machineTagsTest() { UUID entityKey = UUID.randomUUID(); MachineTag machineTag = new MachineTag("ns", "name", "value"); int machineTagKey = 1; - when(getMockMachineTagService().addMachineTag(entityKey, machineTag)).thenReturn(machineTagKey); + when(getMockBaseService().addMachineTag(entityKey, machineTag)).thenReturn(machineTagKey); int machineTagKeyReturned = baseClient.addMachineTag(entityKey, machineTag); assertEquals(machineTagKey, machineTagKeyReturned); machineTag.setKey(machineTagKeyReturned); - when(getMockMachineTagService().listMachineTags(entityKey)) + when(getMockBaseService().listMachineTags(entityKey)) .thenReturn(Collections.singletonList(machineTag)); List machineTags = baseClient.listMachineTags(entityKey); assertEquals(1, machineTags.size()); assertEquals(machineTagKey, machineTags.get(0).getKey()); assertEquals("value", machineTags.get(0).getValue()); - doNothing().when(getMockMachineTagService()).deleteMachineTag(entityKey, machineTagKey); + doNothing().when(getMockBaseService()).deleteMachineTag(entityKey, machineTagKey); assertDoesNotThrow(() -> baseClient.deleteMachineTag(entityKey, machineTagKey)); } @@ -223,12 +219,12 @@ public void identifiersTest() { identifier.setType(IdentifierType.LSID); int identifierKey = 1; - when(getMockIdentifierService().addIdentifier(entityKey, identifier)).thenReturn(identifierKey); + when(getMockBaseService().addIdentifier(entityKey, identifier)).thenReturn(identifierKey); int identifierKeyReturned = baseClient.addIdentifier(entityKey, identifier); assertEquals(identifierKey, identifierKeyReturned); identifier.setKey(identifierKeyReturned); - when(getMockIdentifierService().listIdentifiers(entityKey)) + when(getMockBaseService().listIdentifiers(entityKey)) .thenReturn(Collections.singletonList(identifier)); List identifiers = baseClient.listIdentifiers(entityKey); assertEquals(1, identifiers.size()); @@ -236,7 +232,7 @@ public void identifiersTest() { assertEquals("identifier", identifiers.get(0).getIdentifier()); assertEquals(IdentifierType.LSID, identifiers.get(0).getType()); - doNothing().when(getMockIdentifierService()).deleteIdentifier(entityKey, identifierKey); + doNothing().when(getMockBaseService()).deleteIdentifier(entityKey, identifierKey); assertDoesNotThrow(() -> baseClient.deleteIdentifier(entityKey, identifierKey)); } @@ -247,33 +243,25 @@ public void commentsTest() { Comment comment = new Comment(); comment.setContent("test comment"); int commentKey = 1; - when(getMockCommentService().addComment(entityKey, comment)).thenReturn(commentKey); + when(getMockBaseService().addComment(entityKey, comment)).thenReturn(commentKey); int commentKeyReturned = baseClient.addComment(entityKey, comment); assertEquals(commentKey, commentKeyReturned); comment.setKey(commentKey); - when(getMockCommentService().listComments(entityKey)) + when(getMockBaseService().listComments(entityKey)) .thenReturn(Collections.singletonList(comment)); List comments = baseClient.listComments(entityKey); assertEquals(1, comments.size()); assertEquals(commentKey, comments.get(0).getKey()); assertEquals(comment.getContent(), comments.get(0).getContent()); - doNothing().when(getMockCommentService()).deleteComment(entityKey, commentKey); + doNothing().when(getMockBaseService()).deleteComment(entityKey, commentKey); assertDoesNotThrow(() -> baseClient.deleteComment(entityKey, commentKey)); } void mockGetEntity(UUID key, T entityToReturn) { - when(getMockCrudService().get(key)).thenReturn(entityToReturn); + when(getMockBaseService().get(key)).thenReturn(entityToReturn); } - protected abstract CrudService getMockCrudService(); - - protected abstract TagService getMockTagService(); - - protected abstract MachineTagService getMockMachineTagService(); - - protected abstract IdentifierService getMockIdentifierService(); - - protected abstract CommentService getMockCommentService(); + protected abstract CollectionEntityService getMockBaseService(); } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/CollectionResourceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/CollectionResourceIT.java index 61053b1289..2e2eb1600e 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/CollectionResourceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/CollectionResourceIT.java @@ -7,14 +7,9 @@ import org.gbif.api.model.common.paging.PagingRequest; import org.gbif.api.model.common.paging.PagingResponse; import org.gbif.api.model.registry.search.collections.KeyCodeNameResult; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.service.collections.CollectionService; -import org.gbif.api.service.collections.ContactService; -import org.gbif.api.service.collections.CrudService; -import org.gbif.api.service.collections.OccurrenceMappingService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.PrimaryCollectionEntityService; import org.gbif.api.vocabulary.Country; import org.gbif.registry.search.test.EsManageServer; import org.gbif.registry.service.collections.duplicates.CollectionDuplicatesService; @@ -109,37 +104,7 @@ public void listDeletedTest() { // TODO: merge, suggestions @Override - protected CrudService getMockCrudService() { - return collectionService; - } - - @Override - protected TagService getMockTagService() { - return collectionService; - } - - @Override - protected MachineTagService getMockMachineTagService() { - return collectionService; - } - - @Override - protected IdentifierService getMockIdentifierService() { - return collectionService; - } - - @Override - protected CommentService getMockCommentService() { - return collectionService; - } - - @Override - protected ContactService getMockContactService() { - return collectionService; - } - - @Override - protected OccurrenceMappingService getMockOccurrenceMappingService() { + protected PrimaryCollectionEntityService getMockPrimaryEntityService() { return collectionService; } @@ -156,4 +121,9 @@ protected CollectionClient getClient() { void mockGetEntity(UUID key, Collection entityToReturn) { when(collectionService.getCollectionView(key)).thenReturn(new CollectionView(entityToReturn)); } + + @Override + protected CollectionEntityService getMockBaseService() { + return collectionService; + } } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/InstitutionResourceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/InstitutionResourceIT.java index d5e7a0b973..a0275caf47 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/InstitutionResourceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/InstitutionResourceIT.java @@ -6,14 +6,9 @@ import org.gbif.api.model.common.paging.PagingRequest; import org.gbif.api.model.common.paging.PagingResponse; import org.gbif.api.model.registry.search.collections.KeyCodeNameResult; -import org.gbif.api.service.collections.ContactService; -import org.gbif.api.service.collections.CrudService; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.service.collections.InstitutionService; -import org.gbif.api.service.collections.OccurrenceMappingService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.PrimaryCollectionEntityService; import org.gbif.api.vocabulary.Country; import org.gbif.registry.search.test.EsManageServer; import org.gbif.registry.service.collections.duplicates.DuplicatesService; @@ -110,37 +105,7 @@ public void listDeletedTest() { // TODO: merge, suggestions @Override - protected CrudService getMockCrudService() { - return institutionService; - } - - @Override - protected TagService getMockTagService() { - return institutionService; - } - - @Override - protected MachineTagService getMockMachineTagService() { - return institutionService; - } - - @Override - protected IdentifierService getMockIdentifierService() { - return institutionService; - } - - @Override - protected CommentService getMockCommentService() { - return institutionService; - } - - @Override - protected ContactService getMockContactService() { - return institutionService; - } - - @Override - protected OccurrenceMappingService getMockOccurrenceMappingService() { + protected PrimaryCollectionEntityService getMockPrimaryEntityService() { return institutionService; } @@ -152,4 +117,9 @@ protected DuplicatesService getMockDuplicatesService() { protected InstitutionClient getClient() { return (InstitutionClient) baseClient; } + + @Override + protected CollectionEntityService getMockBaseService() { + return institutionService; + } } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PersonResourceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PersonResourceIT.java index c06bf5adfd..c7d2d6a8cb 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PersonResourceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PersonResourceIT.java @@ -7,12 +7,8 @@ import org.gbif.api.model.common.paging.PagingResponse; import org.gbif.api.model.registry.Identifier; import org.gbif.api.model.registry.search.collections.PersonSuggestResult; -import org.gbif.api.service.collections.CrudService; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.service.collections.PersonService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; import org.gbif.api.vocabulary.Country; import org.gbif.api.vocabulary.IdentifierType; import org.gbif.registry.search.test.EsManageServer; @@ -124,32 +120,12 @@ public void getPersonWithAddressTest() { assertEquals(IdentifierType.IH_IRN, personSaved.getIdentifiers().get(0).getType()); } - @Override - protected CrudService getMockCrudService() { - return personService; - } - - @Override - protected TagService getMockTagService() { - return personService; - } - - @Override - protected MachineTagService getMockMachineTagService() { - return personService; - } - - @Override - protected IdentifierService getMockIdentifierService() { - return personService; + protected PersonClient getClient() { + return (PersonClient) baseClient; } @Override - protected CommentService getMockCommentService() { + protected CollectionEntityService getMockBaseService() { return personService; } - - protected PersonClient getClient() { - return (PersonClient) baseClient; - } } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PrimaryCollectionEntityResourceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PrimaryCollectionEntityResourceIT.java index 40599fbda0..7b3c86f52f 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PrimaryCollectionEntityResourceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/resource/PrimaryCollectionEntityResourceIT.java @@ -16,11 +16,11 @@ package org.gbif.registry.ws.it.collections.resource; import org.gbif.api.model.collections.Address; -import org.gbif.api.model.collections.CollectionEntity; import org.gbif.api.model.collections.Contactable; import org.gbif.api.model.collections.OccurrenceMappeable; import org.gbif.api.model.collections.OccurrenceMapping; import org.gbif.api.model.collections.Person; +import org.gbif.api.model.collections.PrimaryCollectionEntity; import org.gbif.api.model.collections.duplicates.Duplicate; import org.gbif.api.model.collections.duplicates.DuplicatesRequest; import org.gbif.api.model.collections.duplicates.DuplicatesResult; @@ -29,8 +29,7 @@ import org.gbif.api.model.registry.LenientEquals; import org.gbif.api.model.registry.MachineTaggable; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.ContactService; -import org.gbif.api.service.collections.OccurrenceMappingService; +import org.gbif.api.service.collections.PrimaryCollectionEntityService; import org.gbif.api.vocabulary.Country; import org.gbif.registry.persistence.mapper.collections.params.DuplicatesSearchParams; import org.gbif.registry.search.test.EsManageServer; @@ -57,8 +56,8 @@ public abstract class PrimaryCollectionEntityResourceIT< T extends - CollectionEntity & Taggable & MachineTaggable & Identifiable & Contactable & Commentable - & OccurrenceMappeable & LenientEquals> + PrimaryCollectionEntity & Taggable & MachineTaggable & Identifiable & Contactable + & Commentable & OccurrenceMappeable & LenientEquals> extends BaseCollectionEntityResourceIT { public PrimaryCollectionEntityResourceIT( @@ -82,19 +81,19 @@ public void contactsTest() { person2.setKey(UUID.randomUUID()); // add contact - doNothing().when(getMockContactService()).addContact(any(UUID.class), any(UUID.class)); + doNothing().when(getMockPrimaryEntityService()).addContact(any(UUID.class), any(UUID.class)); assertDoesNotThrow( () -> getPrimaryCollectionEntityClient().addContact(UUID.randomUUID(), UUID.randomUUID())); // list contacts - when(getMockContactService().listContacts(any(UUID.class))) + when(getMockPrimaryEntityService().listContacts(any(UUID.class))) .thenReturn(Arrays.asList(person1, person2)); List contactsEntity1 = getPrimaryCollectionEntityClient().listContacts(UUID.randomUUID()); assertEquals(2, contactsEntity1.size()); // remove contacts - doNothing().when(getMockContactService()).removeContact(any(UUID.class), any(UUID.class)); + doNothing().when(getMockPrimaryEntityService()).removeContact(any(UUID.class), any(UUID.class)); assertDoesNotThrow( () -> getPrimaryCollectionEntityClient().removeContact(UUID.randomUUID(), UUID.randomUUID())); @@ -139,8 +138,7 @@ public void occurrenceMappingsTest() { occurrenceMapping.setDatasetKey(UUID.randomUUID()); int key = 1; - when(getMockOccurrenceMappingService() - .addOccurrenceMapping(any(UUID.class), eq(occurrenceMapping))) + when(getMockPrimaryEntityService().addOccurrenceMapping(any(UUID.class), eq(occurrenceMapping))) .thenReturn(key); int occurrenceMappingKey = getPrimaryCollectionEntityClient() @@ -148,7 +146,7 @@ public void occurrenceMappingsTest() { assertEquals(key, occurrenceMappingKey); occurrenceMapping.setKey(occurrenceMappingKey); - when(getMockOccurrenceMappingService().listOccurrenceMappings(any(UUID.class))) + when(getMockPrimaryEntityService().listOccurrenceMappings(any(UUID.class))) .thenReturn(Collections.singletonList(occurrenceMapping)); List mappings = @@ -156,7 +154,7 @@ public void occurrenceMappingsTest() { assertEquals(1, mappings.size()); doNothing() - .when(getMockOccurrenceMappingService()) + .when(getMockPrimaryEntityService()) .deleteOccurrenceMapping(any(UUID.class), eq(occurrenceMappingKey)); assertDoesNotThrow( () -> @@ -191,9 +189,7 @@ protected PrimaryCollectionEntityClient getPrimaryCollectionEntityClient() { return (PrimaryCollectionEntityClient) baseClient; } - protected abstract ContactService getMockContactService(); - - protected abstract OccurrenceMappingService getMockOccurrenceMappingService(); + protected abstract PrimaryCollectionEntityService getMockPrimaryEntityService(); protected abstract DuplicatesService getMockDuplicatesService(); } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseCollectionEntityServiceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseCollectionEntityServiceIT.java index e0be5f1a2d..677d99a7a6 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseCollectionEntityServiceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseCollectionEntityServiceIT.java @@ -27,7 +27,7 @@ import org.gbif.api.model.registry.MachineTaggable; import org.gbif.api.model.registry.Tag; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.CrudService; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.service.registry.CommentService; import org.gbif.api.service.registry.IdentifierService; import org.gbif.api.service.registry.MachineTagService; @@ -64,7 +64,7 @@ public abstract class BaseCollectionEntityServiceIT< & LenientEquals> extends BaseServiceIT { - protected final CrudService crudService; + protected final CollectionEntityService collectionEntityService; protected final Class paramType; protected final TestData testData; @@ -76,13 +76,13 @@ public abstract class BaseCollectionEntityServiceIT< protected TestCaseDatabaseInitializer databaseRule = new TestCaseDatabaseInitializer(); public BaseCollectionEntityServiceIT( - CrudService crudService, + CollectionEntityService collectionEntityService, SimplePrincipalProvider principalProvider, EsManageServer esServer, IdentityService identityService, Class paramType) { super(principalProvider, esServer); - this.crudService = crudService; + this.collectionEntityService = collectionEntityService; this.paramType = paramType; this.testData = TestDataFactory.create(paramType); collectionsDatabaseInitializer = new CollectionsDatabaseInitializer(identityService); @@ -92,11 +92,11 @@ public BaseCollectionEntityServiceIT( public void crudTest() { // create T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); assertNotNull(key); - T entitySaved = crudService.get(key); + T entitySaved = collectionEntityService.get(key); assertEquals(key, entitySaved.getKey()); assertTrue(entity.lenientEquals(entitySaved)); assertNotNull(entitySaved.getCreatedBy()); @@ -106,70 +106,73 @@ public void crudTest() { // update entity = testData.updateEntity(entitySaved); - crudService.update(entity); + collectionEntityService.update(entity); - entitySaved = crudService.get(key); + entitySaved = collectionEntityService.get(key); assertTrue(entity.lenientEquals(entitySaved)); assertNotEquals(entitySaved.getCreated(), entitySaved.getModified()); // delete - crudService.delete(key); - entitySaved = crudService.get(key); + collectionEntityService.delete(key); + entitySaved = collectionEntityService.get(key); assertNotNull(entitySaved.getDeleted()); } @Test public void createInvalidEntityTest() { - assertThrows(ValidationException.class, () -> crudService.create(testData.newInvalidEntity())); + assertThrows( + ValidationException.class, + () -> collectionEntityService.create(testData.newInvalidEntity())); } @Test public void deleteMissingEntityTest() { - assertThrows(IllegalArgumentException.class, () -> crudService.delete(UUID.randomUUID())); + assertThrows( + IllegalArgumentException.class, () -> collectionEntityService.delete(UUID.randomUUID())); } @Test public void updateDeletedEntityTest() { T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); entity.setKey(key); - crudService.delete(key); + collectionEntityService.delete(key); - T entity2 = crudService.get(key); + T entity2 = collectionEntityService.get(key); assertNotNull(entity2.getDeleted()); - assertThrows(IllegalArgumentException.class, () -> crudService.update(entity2)); + assertThrows(IllegalArgumentException.class, () -> collectionEntityService.update(entity2)); } @Test public void restoreDeletedEntityTest() { T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); entity.setKey(key); - crudService.delete(key); - entity = crudService.get(key); + collectionEntityService.delete(key); + entity = collectionEntityService.get(key); assertNotNull(entity.getDeleted()); // restore it entity.setDeleted(null); - crudService.update(entity); - entity = crudService.get(key); + collectionEntityService.update(entity); + entity = collectionEntityService.get(key); assertNull(entity.getDeleted()); } @Test public void updateInvalidEntityTest() { T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); T newEntity = testData.newInvalidEntity(); newEntity.setKey(key); - assertThrows(ValidationException.class, () -> crudService.update(newEntity)); + assertThrows(ValidationException.class, () -> collectionEntityService.update(newEntity)); } @Test public void getMissingEntity() { try { - T entity = crudService.get(UUID.randomUUID()); + T entity = collectionEntityService.get(UUID.randomUUID()); assertNull(entity); } catch (Exception ex) { assertEquals(NotFoundException.class, ex.getClass()); @@ -192,8 +195,8 @@ public void createFullEntityTest() { identifier.setType(IdentifierType.LSID); entity.setIdentifiers(Collections.singletonList(identifier)); - UUID key = crudService.create(entity); - T entitySaved = crudService.get(key); + UUID key = collectionEntityService.create(entity); + T entitySaved = collectionEntityService.get(key); assertEquals(1, entitySaved.getMachineTags().size()); assertEquals("value", entitySaved.getMachineTags().get(0).getValue()); @@ -206,9 +209,9 @@ public void createFullEntityTest() { @Test public void tagsTest() { - TagService tagService = (TagService) crudService; + TagService tagService = (TagService) collectionEntityService; - UUID key = crudService.create(testData.newEntity()); + UUID key = collectionEntityService.create(testData.newEntity()); Tag tag = new Tag(); tag.setValue("value"); @@ -225,10 +228,10 @@ public void tagsTest() { @Test public void machineTagsTest() { - MachineTagService machineTagService = (MachineTagService) crudService; + MachineTagService machineTagService = (MachineTagService) collectionEntityService; T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); MachineTag machineTag = new MachineTag("ns", "name", "value"); int machineTagKey = machineTagService.addMachineTag(key, machineTag); @@ -244,10 +247,10 @@ public void machineTagsTest() { @Test public void identifiersTest() { - IdentifierService identifierService = (IdentifierService) crudService; + IdentifierService identifierService = (IdentifierService) collectionEntityService; T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); Identifier identifier = new Identifier(); identifier.setIdentifier("identifier"); @@ -267,10 +270,10 @@ public void identifiersTest() { @Test public void commentsTest() { - CommentService commentService = (CommentService) crudService; + CommentService commentService = (CommentService) collectionEntityService; T entity = testData.newEntity(); - UUID key = crudService.create(entity); + UUID key = collectionEntityService.create(entity); Comment comment = new Comment(); comment.setContent("test comment"); diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseServiceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseServiceIT.java index 563816c080..367e9cb177 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseServiceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/BaseServiceIT.java @@ -54,13 +54,13 @@ /** Base class for IT tests that initializes data sources and basic security settings. */ @ExtendWith(SpringExtension.class) -@SpringBootTest(classes = {RegistryIntegrationTestsConfiguration.class}) +@SpringBootTest(classes = RegistryIntegrationTestsConfiguration.class) @ContextConfiguration( initializers = { BaseServiceIT.ContextInitializer.class, BaseServiceIT.EsContainerContextInitializer.class }) -@ActiveProfiles({"test"}) +@ActiveProfiles("test") public class BaseServiceIT { public static class EsContainerContextInitializer @@ -173,13 +173,4 @@ protected void resetSecurityContext(String principal, UserRole role) { public SimplePrincipalProvider getSimplePrincipalProvider() { return simplePrincipalProvider; } - - // @TestConfiguration - // @Profile("mock") - // public static class MockConfig { - // - // // mocked because it needs the mockMvc bean and the tests that extend this class don't use - // it - // @MockBean RequestTestFixture requestTestFixture; - // } } diff --git a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/CollectionServiceIT.java b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/CollectionServiceIT.java index bd645967f0..1bbf0478ed 100644 --- a/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/CollectionServiceIT.java +++ b/registry-integration-tests/src/test/java/org/gbif/registry/ws/it/collections/service/CollectionServiceIT.java @@ -67,7 +67,7 @@ public class CollectionServiceIT extends PrimaryCollectionEntityServiceIT primaryCollectionEntityService; private final DuplicatesService duplicatesService; public PrimaryCollectionEntityServiceIT( - CrudService crudService, + PrimaryCollectionEntityService primaryCollectionEntityService, PersonService personService, DatasetService datasetService, NodeService nodeService, @@ -102,18 +100,15 @@ public PrimaryCollectionEntityServiceIT( SimplePrincipalProvider principalProvider, EsManageServer esServer, IdentityService identityService, - ContactService contactService, - OccurrenceMappingService occurrenceMappingService, DuplicatesService duplicatesService, Class paramType) { - super(crudService, principalProvider, esServer, identityService, paramType); + super(primaryCollectionEntityService, principalProvider, esServer, identityService, paramType); this.personService = personService; this.datasetService = datasetService; this.nodeService = nodeService; this.organizationService = organizationService; this.installationService = installationService; - this.contactService = contactService; - this.occurrenceMappingService = occurrenceMappingService; + this.primaryCollectionEntityService = primaryCollectionEntityService; this.duplicatesService = duplicatesService; } @@ -139,9 +134,9 @@ public void beforeAll(ExtensionContext extensionContext) throws Exception { @Test public void contactsTest() { // entities - UUID entityKey1 = crudService.create(testData.newEntity()); - UUID entityKey2 = crudService.create(testData.newEntity()); - UUID entityKey3 = crudService.create(testData.newEntity()); + UUID entityKey1 = primaryCollectionEntityService.create(testData.newEntity()); + UUID entityKey2 = primaryCollectionEntityService.create(testData.newEntity()); + UUID entityKey3 = primaryCollectionEntityService.create(testData.newEntity()); // contacts Person person1 = new Person(); @@ -153,34 +148,34 @@ public void contactsTest() { UUID personKey2 = personService.create(person2); // add contacts - contactService.addContact(entityKey1, personKey1); - contactService.addContact(entityKey1, personKey2); - contactService.addContact(entityKey2, personKey2); + primaryCollectionEntityService.addContact(entityKey1, personKey1); + primaryCollectionEntityService.addContact(entityKey1, personKey2); + primaryCollectionEntityService.addContact(entityKey2, personKey2); // list contacts - List contactsEntity1 = contactService.listContacts(entityKey1); + List contactsEntity1 = primaryCollectionEntityService.listContacts(entityKey1); assertEquals(2, contactsEntity1.size()); - List contactsEntity2 = contactService.listContacts(entityKey2); + List contactsEntity2 = primaryCollectionEntityService.listContacts(entityKey2); assertEquals(1, contactsEntity2.size()); assertEquals("name2", contactsEntity2.get(0).getFirstName()); - assertEquals(0, contactService.listContacts(entityKey3).size()); + assertEquals(0, primaryCollectionEntityService.listContacts(entityKey3).size()); // remove contacts - contactService.removeContact(entityKey1, personKey2); - contactsEntity1 = contactService.listContacts(entityKey1); + primaryCollectionEntityService.removeContact(entityKey1, personKey2); + contactsEntity1 = primaryCollectionEntityService.listContacts(entityKey1); assertEquals(1, contactsEntity1.size()); assertEquals("name1", contactsEntity1.get(0).getFirstName()); - contactService.removeContact(entityKey2, personKey2); - assertEquals(0, contactService.listContacts(entityKey2).size()); + primaryCollectionEntityService.removeContact(entityKey2, personKey2); + assertEquals(0, primaryCollectionEntityService.listContacts(entityKey2).size()); } @Test public void duplicateContactTest() { // entities - UUID entityKey1 = crudService.create(testData.newEntity()); + UUID entityKey1 = primaryCollectionEntityService.create(testData.newEntity()); // contacts Person person1 = new Person(); @@ -188,17 +183,19 @@ public void duplicateContactTest() { UUID personKey1 = personService.create(person1); // add one contact - contactService.addContact(entityKey1, personKey1); - assertThrows(RuntimeException.class, () -> contactService.addContact(entityKey1, personKey1)); + primaryCollectionEntityService.addContact(entityKey1, personKey1); + assertThrows( + RuntimeException.class, + () -> primaryCollectionEntityService.addContact(entityKey1, personKey1)); } @Test public void updateAddressesTest() { // entities T newEntity = testData.newEntity(); - UUID entityKey = crudService.create(newEntity); + UUID entityKey = primaryCollectionEntityService.create(newEntity); assertNotNull(entityKey); - T entity = crudService.get(entityKey); + T entity = primaryCollectionEntityService.get(entityKey); assertTrue(newEntity.lenientEquals(entity)); // update adding address @@ -214,8 +211,8 @@ public void updateAddressesTest() { mailingAddress.setCity("city mailing"); entity.setMailingAddress(mailingAddress); - crudService.update(entity); - entity = crudService.get(entityKey); + primaryCollectionEntityService.update(entity); + entity = primaryCollectionEntityService.get(entityKey); address = entity.getAddress(); mailingAddress = entity.getMailingAddress(); @@ -236,8 +233,8 @@ public void updateAddressesTest() { address.setAddress("address2"); mailingAddress.setAddress("mailing address2"); - crudService.update(entity); - entity = crudService.get(entityKey); + primaryCollectionEntityService.update(entity); + entity = primaryCollectionEntityService.get(entityKey); assertNotNull(entity.getAddress()); assertEquals("address2", entity.getAddress().getAddress()); assertNotNull(entity.getMailingAddress()); @@ -246,8 +243,8 @@ public void updateAddressesTest() { // delete address entity.setAddress(null); entity.setMailingAddress(null); - crudService.update(entity); - entity = crudService.get(entityKey); + primaryCollectionEntityService.update(entity); + entity = primaryCollectionEntityService.get(entityKey); assertNull(entity.getAddress()); assertNull(entity.getMailingAddress()); } @@ -255,20 +252,21 @@ public void updateAddressesTest() { @Test public void occurrenceMappingsTest() { T entity = testData.newEntity(); - UUID entityKey = crudService.create(entity); + UUID entityKey = primaryCollectionEntityService.create(entity); Dataset dataset = createDataset(); OccurrenceMapping occurrenceMapping = new OccurrenceMapping(); occurrenceMapping.setCode("code"); occurrenceMapping.setDatasetKey(dataset.getKey()); int occurrenceMappingKey = - occurrenceMappingService.addOccurrenceMapping(entityKey, occurrenceMapping); + primaryCollectionEntityService.addOccurrenceMapping(entityKey, occurrenceMapping); - List mappings = occurrenceMappingService.listOccurrenceMappings(entityKey); + List mappings = + primaryCollectionEntityService.listOccurrenceMappings(entityKey); assertEquals(1, mappings.size()); - occurrenceMappingService.deleteOccurrenceMapping(entityKey, occurrenceMappingKey); - mappings = occurrenceMappingService.listOccurrenceMappings(entityKey); + primaryCollectionEntityService.deleteOccurrenceMapping(entityKey, occurrenceMappingKey); + mappings = primaryCollectionEntityService.listOccurrenceMappings(entityKey); assertTrue(mappings.isEmpty()); } diff --git a/registry-service/src/main/java/org/gbif/registry/service/collections/BaseCollectionEntityService.java b/registry-service/src/main/java/org/gbif/registry/service/collections/BaseCollectionEntityService.java index 09500f6038..b895684a04 100644 --- a/registry-service/src/main/java/org/gbif/registry/service/collections/BaseCollectionEntityService.java +++ b/registry-service/src/main/java/org/gbif/registry/service/collections/BaseCollectionEntityService.java @@ -10,11 +10,7 @@ import org.gbif.api.model.registry.PrePersist; import org.gbif.api.model.registry.Tag; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.CrudService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.CollectionEntityService; import org.gbif.api.vocabulary.TagName; import org.gbif.api.vocabulary.TagNamespace; import org.gbif.registry.events.EventManager; @@ -49,7 +45,7 @@ @Validated public abstract class BaseCollectionEntityService< T extends CollectionEntity & Taggable & Identifiable & MachineTaggable & Commentable> - implements CrudService, TagService, IdentifierService, MachineTagService, CommentService { + implements CollectionEntityService { private static final Logger LOG = LoggerFactory.getLogger(BaseCollectionEntityService.class); @@ -321,9 +317,4 @@ protected void preUpdate(T entity) { final Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); entity.setModifiedBy(authentication.getName()); } - - @Secured({GRSCICOLL_ADMIN_ROLE, GRSCICOLL_EDITOR_ROLE}) - @Transactional - @Override - public abstract void update(T entity); } diff --git a/registry-service/src/main/java/org/gbif/registry/service/collections/PrimaryCollectionEntityService.java b/registry-service/src/main/java/org/gbif/registry/service/collections/BasePrimaryCollectionEntityService.java similarity index 97% rename from registry-service/src/main/java/org/gbif/registry/service/collections/PrimaryCollectionEntityService.java rename to registry-service/src/main/java/org/gbif/registry/service/collections/BasePrimaryCollectionEntityService.java index 5dff0bfc05..e55212bbfc 100644 --- a/registry-service/src/main/java/org/gbif/registry/service/collections/PrimaryCollectionEntityService.java +++ b/registry-service/src/main/java/org/gbif/registry/service/collections/BasePrimaryCollectionEntityService.java @@ -18,6 +18,7 @@ import org.gbif.api.model.registry.Taggable; import org.gbif.api.service.collections.ContactService; import org.gbif.api.service.collections.OccurrenceMappingService; +import org.gbif.api.service.collections.PrimaryCollectionEntityService; import org.gbif.registry.events.EventManager; import org.gbif.registry.events.collections.ChangedCollectionEntityComponentEvent; import org.gbif.registry.events.collections.CreateCollectionEntityEvent; @@ -53,18 +54,18 @@ import static org.gbif.registry.security.UserRoles.GRSCICOLL_EDITOR_ROLE; @Validated -public abstract class PrimaryCollectionEntityService< +public abstract class BasePrimaryCollectionEntityService< T extends PrimaryCollectionEntity & Taggable & Identifiable & MachineTaggable & Contactable & Commentable & OccurrenceMappeable> - extends BaseCollectionEntityService implements ContactService, OccurrenceMappingService { + extends BaseCollectionEntityService implements PrimaryCollectionEntityService { private final ContactableMapper contactableMapper; private final OccurrenceMappingMapper occurrenceMappingMapper; private final OccurrenceMappeableMapper occurrenceMappeableMapper; private final AddressMapper addressMapper; - protected PrimaryCollectionEntityService( + protected BasePrimaryCollectionEntityService( Class objectClass, BaseMapper baseMapper, AddressMapper addressMapper, diff --git a/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultCollectionService.java b/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultCollectionService.java index 446dafa018..c713d844e6 100644 --- a/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultCollectionService.java +++ b/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultCollectionService.java @@ -34,7 +34,7 @@ @Validated @Service -public class DefaultCollectionService extends PrimaryCollectionEntityService +public class DefaultCollectionService extends BasePrimaryCollectionEntityService implements CollectionService { private final CollectionMapper collectionMapper; diff --git a/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultInstitutionService.java b/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultInstitutionService.java index e74f3f6068..2232d98f09 100644 --- a/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultInstitutionService.java +++ b/registry-service/src/main/java/org/gbif/registry/service/collections/DefaultInstitutionService.java @@ -30,7 +30,7 @@ @Validated @Service -public class DefaultInstitutionService extends PrimaryCollectionEntityService +public class DefaultInstitutionService extends BasePrimaryCollectionEntityService implements InstitutionService { private final InstitutionMapper institutionMapper; diff --git a/registry-service/src/main/java/org/gbif/registry/service/collections/merge/BaseMergeService.java b/registry-service/src/main/java/org/gbif/registry/service/collections/merge/BaseMergeService.java index d03eea1969..883ae52677 100644 --- a/registry-service/src/main/java/org/gbif/registry/service/collections/merge/BaseMergeService.java +++ b/registry-service/src/main/java/org/gbif/registry/service/collections/merge/BaseMergeService.java @@ -19,17 +19,31 @@ import org.gbif.api.model.collections.Contactable; import org.gbif.api.model.collections.OccurrenceMappeable; import org.gbif.api.model.collections.OccurrenceMapping; -import org.gbif.api.model.registry.*; +import org.gbif.api.model.registry.Commentable; +import org.gbif.api.model.registry.Identifiable; +import org.gbif.api.model.registry.Identifier; +import org.gbif.api.model.registry.MachineTaggable; +import org.gbif.api.model.registry.Taggable; import org.gbif.api.vocabulary.IdentifierType; import org.gbif.registry.persistence.ContactableMapper; import org.gbif.registry.persistence.mapper.IdentifierMapper; import org.gbif.registry.persistence.mapper.MachineTagMapper; -import org.gbif.registry.persistence.mapper.collections.*; +import org.gbif.registry.persistence.mapper.collections.BaseMapper; +import org.gbif.registry.persistence.mapper.collections.MergeableMapper; +import org.gbif.registry.persistence.mapper.collections.OccurrenceMappeableMapper; +import org.gbif.registry.persistence.mapper.collections.OccurrenceMappingMapper; +import org.gbif.registry.persistence.mapper.collections.PersonMapper; import org.gbif.registry.security.SecurityContextCheck; import org.gbif.registry.security.UserRoles; import java.lang.reflect.InvocationTargetException; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; import java.util.function.UnaryOperator; import org.springframework.security.access.annotation.Secured; @@ -40,7 +54,7 @@ import com.google.common.base.Strings; import static com.google.common.base.Preconditions.checkArgument; -import static org.gbif.registry.domain.collections.Constants.*; +import static org.gbif.registry.domain.collections.Constants.IDIGBIO_NAMESPACE; import static org.gbif.registry.security.UserRoles.GRSCICOLL_ADMIN_ROLE; import static org.gbif.registry.security.UserRoles.IDIGBIO_GRSCICOLL_EDITOR_ROLE; @@ -50,7 +64,8 @@ public abstract class BaseMergeService< & Taggable & Commentable> implements MergeService { - // TODO: usar los servicios en lugar de los mappers + // TODO: usar los servicios en lugar de los mappers. Necesito nuevos servicios para el audit log + // tb (como por ejemplo uno para mover un identifer) protected final BaseMapper baseMapper; protected final MergeableMapper mergeableMapper; diff --git a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/BaseCollectionEntityResource.java b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/BaseCollectionEntityResource.java index 25d2ecb9cd..fcdfcd17c2 100644 --- a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/BaseCollectionEntityResource.java +++ b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/BaseCollectionEntityResource.java @@ -25,11 +25,7 @@ import org.gbif.api.model.registry.MachineTaggable; import org.gbif.api.model.registry.Tag; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.CrudService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.CollectionEntityService; import java.util.List; import java.util.UUID; @@ -56,62 +52,49 @@ public abstract class BaseCollectionEntityResource< private static final Logger LOG = LoggerFactory.getLogger(BaseCollectionEntityResource.class); protected final Class objectClass; - protected final CrudService crudService; - protected final IdentifierService identifierService; - protected final TagService tagService; - protected final MachineTagService machineTagService; - protected final CommentService commentService; + protected final CollectionEntityService collectionEntityService; protected BaseCollectionEntityResource( - Class objectClass, - CrudService crudService, - IdentifierService identifierService, - TagService tagService, - MachineTagService machineTagService, - CommentService commentService) { + Class objectClass, CollectionEntityService collectionEntityService) { this.objectClass = objectClass; - this.crudService = crudService; - this.identifierService = identifierService; - this.tagService = tagService; - this.machineTagService = machineTagService; - this.commentService = commentService; + this.collectionEntityService = collectionEntityService; } @DeleteMapping("{key}") public void delete(@PathVariable UUID key) { - crudService.delete(key); + collectionEntityService.delete(key); } @PostMapping(value = "{key}/identifier", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public int addIdentifier( @PathVariable("key") UUID entityKey, @RequestBody @Trim Identifier identifier) { - return identifierService.addIdentifier(entityKey, identifier); + return collectionEntityService.addIdentifier(entityKey, identifier); } @DeleteMapping("{key}/identifier/{identifierKey}") @Transactional public void deleteIdentifier( @PathVariable("key") UUID entityKey, @PathVariable int identifierKey) { - identifierService.deleteIdentifier(entityKey, identifierKey); + collectionEntityService.deleteIdentifier(entityKey, identifierKey); } @GetMapping("{key}/identifier") @Nullable public List listIdentifiers(@PathVariable UUID key) { - return identifierService.listIdentifiers(key); + return collectionEntityService.listIdentifiers(key); } @PostMapping(value = "{key}/tag", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public int addTag(@PathVariable("key") UUID entityKey, @RequestBody @Trim Tag tag) { - return tagService.addTag(entityKey, tag); + return collectionEntityService.addTag(entityKey, tag); } @DeleteMapping("{key}/tag/{tagKey}") @Transactional public void deleteTag(@PathVariable("key") UUID entityKey, @PathVariable int tagKey) { - tagService.deleteTag(entityKey, tagKey); + collectionEntityService.deleteTag(entityKey, tagKey); } @GetMapping("{key}/tag") @@ -119,26 +102,26 @@ public void deleteTag(@PathVariable("key") UUID entityKey, @PathVariable int tag public List listTags( @PathVariable("key") UUID key, @RequestParam(value = "owner", required = false) String owner) { - return tagService.listTags(key, owner); + return collectionEntityService.listTags(key, owner); } @PostMapping(value = "{key}/machineTag", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public int addMachineTag( @PathVariable("key") UUID targetEntityKey, @RequestBody @Trim MachineTag machineTag) { - return machineTagService.addMachineTag(targetEntityKey, machineTag); + return collectionEntityService.addMachineTag(targetEntityKey, machineTag); } @DeleteMapping("{key}/machineTag/{machineTagKey:[0-9]+}") public void deleteMachineTagByMachineTagKey( @PathVariable("key") UUID targetEntityKey, @PathVariable("machineTagKey") int machineTagKey) { - machineTagService.deleteMachineTag(targetEntityKey, machineTagKey); + collectionEntityService.deleteMachineTag(targetEntityKey, machineTagKey); } @DeleteMapping("{key}/machineTag/{namespace:.*[^0-9]+.*}") public void deleteMachineTagsByNamespace( @PathVariable("key") UUID targetEntityKey, @PathVariable("namespace") String namespace) { - machineTagService.deleteMachineTags(targetEntityKey, namespace); + collectionEntityService.deleteMachineTags(targetEntityKey, namespace); } @DeleteMapping("{key}/machineTag/{namespace}/{name}") @@ -146,29 +129,29 @@ public void deleteMachineTags( @PathVariable("key") UUID targetEntityKey, @PathVariable("namespace") String namespace, @PathVariable("name") String name) { - machineTagService.deleteMachineTags(targetEntityKey, namespace, name); + collectionEntityService.deleteMachineTags(targetEntityKey, namespace, name); } @GetMapping("{key}/machineTag") public List listMachineTags(@PathVariable("key") UUID targetEntityKey) { - return machineTagService.listMachineTags(targetEntityKey); + return collectionEntityService.listMachineTags(targetEntityKey); } @PostMapping(value = "{key}/comment", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public int addComment( @PathVariable("key") UUID targetEntityKey, @RequestBody @Trim Comment comment) { - return commentService.addComment(targetEntityKey, comment); + return collectionEntityService.addComment(targetEntityKey, comment); } @DeleteMapping("{key}/comment/{commentKey}") public void deleteComment( @PathVariable("key") UUID targetEntityKey, @PathVariable("commentKey") int commentKey) { - commentService.deleteComment(targetEntityKey, commentKey); + collectionEntityService.deleteComment(targetEntityKey, commentKey); } @GetMapping(value = "{key}/comment") public List listComments(@PathVariable("key") UUID targetEntityKey) { - return commentService.listComments(targetEntityKey); + return collectionEntityService.listComments(targetEntityKey); } } diff --git a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/CollectionResource.java b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/CollectionResource.java index 539db0f001..545feac21b 100644 --- a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/CollectionResource.java +++ b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/CollectionResource.java @@ -47,7 +47,6 @@ public class CollectionResource extends PrimaryCollectionEntityResource { - private final CollectionDuplicatesService duplicatesService; public final CollectionService collectionService; public CollectionResource( @@ -58,16 +57,9 @@ public CollectionResource( super( collectionMergeService, collectionService, - collectionService, - collectionService, - collectionService, - collectionService, - collectionService, - collectionService, collectionChangeSuggestionService, duplicatesService, Collection.class); - this.duplicatesService = duplicatesService; this.collectionService = collectionService; } diff --git a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/InstitutionResource.java b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/InstitutionResource.java index dcbe279d33..dcfd41aa69 100644 --- a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/InstitutionResource.java +++ b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/InstitutionResource.java @@ -17,8 +17,6 @@ import org.gbif.api.annotation.NullToNotFound; import org.gbif.api.model.collections.Institution; -import org.gbif.api.model.collections.duplicates.DuplicatesRequest; -import org.gbif.api.model.collections.duplicates.DuplicatesResult; import org.gbif.api.model.collections.merge.ConvertToCollectionParams; import org.gbif.api.model.collections.request.InstitutionSearchRequest; import org.gbif.api.model.collections.suggestions.InstitutionChangeSuggestion; @@ -26,7 +24,6 @@ import org.gbif.api.model.common.paging.PagingResponse; import org.gbif.api.model.registry.search.collections.KeyCodeNameResult; import org.gbif.api.service.collections.InstitutionService; -import org.gbif.registry.persistence.mapper.collections.params.DuplicatesSearchParams; import org.gbif.registry.service.collections.duplicates.InstitutionDuplicatesService; import org.gbif.registry.service.collections.merge.InstitutionMergeService; import org.gbif.registry.service.collections.suggestions.InstitutionChangeSuggestionService; @@ -43,8 +40,6 @@ import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; -import com.google.common.base.Preconditions; - /** * Class that acts both as the WS endpoint for {@link Institution} entities and also provides an * * implementation of {@link InstitutionService}. @@ -56,7 +51,6 @@ public class InstitutionResource private final InstitutionService institutionService; private final InstitutionMergeService institutionMergeService; - private final InstitutionDuplicatesService duplicatesService; public InstitutionResource( InstitutionMergeService institutionMergeService, @@ -66,18 +60,11 @@ public InstitutionResource( super( institutionMergeService, institutionService, - institutionService, - institutionService, - institutionService, - institutionService, - institutionService, - institutionService, institutionChangeSuggestionService, duplicatesService, Institution.class); this.institutionService = institutionService; this.institutionMergeService = institutionMergeService; - this.duplicatesService = duplicatesService; } @GetMapping("{key}") diff --git a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PersonResource.java b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PersonResource.java index edc447cded..6495c9698e 100644 --- a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PersonResource.java +++ b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PersonResource.java @@ -26,8 +26,6 @@ import java.util.List; import java.util.UUID; -import javax.validation.Valid; - import org.springframework.http.MediaType; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; @@ -47,7 +45,7 @@ public class PersonResource extends BaseCollectionEntityResource { private final PersonService personService; public PersonResource(PersonService personService) { - super(Person.class, personService, personService, personService, personService, personService); + super(Person.class, personService); this.personService = personService; } diff --git a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PrimaryCollectionEntityResource.java b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PrimaryCollectionEntityResource.java index bac2d47f69..148277888d 100644 --- a/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PrimaryCollectionEntityResource.java +++ b/registry-ws/src/main/java/org/gbif/registry/ws/resources/collections/PrimaryCollectionEntityResource.java @@ -21,6 +21,7 @@ import org.gbif.api.model.collections.OccurrenceMappeable; import org.gbif.api.model.collections.OccurrenceMapping; import org.gbif.api.model.collections.Person; +import org.gbif.api.model.collections.PrimaryCollectionEntity; import org.gbif.api.model.collections.duplicates.DuplicatesRequest; import org.gbif.api.model.collections.duplicates.DuplicatesResult; import org.gbif.api.model.collections.merge.MergeParams; @@ -34,13 +35,7 @@ import org.gbif.api.model.registry.Identifiable; import org.gbif.api.model.registry.MachineTaggable; import org.gbif.api.model.registry.Taggable; -import org.gbif.api.service.collections.ContactService; -import org.gbif.api.service.collections.CrudService; -import org.gbif.api.service.collections.OccurrenceMappingService; -import org.gbif.api.service.registry.CommentService; -import org.gbif.api.service.registry.IdentifierService; -import org.gbif.api.service.registry.MachineTagService; -import org.gbif.api.service.registry.TagService; +import org.gbif.api.service.collections.PrimaryCollectionEntityService; import org.gbif.api.vocabulary.Country; import org.gbif.registry.persistence.mapper.collections.params.DuplicatesSearchParams; import org.gbif.registry.service.collections.duplicates.DuplicatesService; @@ -74,88 +69,77 @@ @RequestMapping(produces = MediaType.APPLICATION_JSON_VALUE) public abstract class PrimaryCollectionEntityResource< T extends - CollectionEntity & Taggable & Identifiable & MachineTaggable & Contactable & Commentable - & OccurrenceMappeable, + PrimaryCollectionEntity & Taggable & Identifiable & MachineTaggable & Contactable + & Commentable & OccurrenceMappeable, R extends ChangeSuggestion> extends BaseCollectionEntityResource { private final MergeService mergeService; - private final CrudService crudService; - private final ContactService contactService; - private final OccurrenceMappingService occurrenceMappingService; + private final PrimaryCollectionEntityService primaryCollectionEntityService; private final ChangeSuggestionService changeSuggestionService; private final DuplicatesService duplicatesService; protected PrimaryCollectionEntityResource( MergeService mergeService, - CrudService crudService, - ContactService contactService, - IdentifierService identifierService, - TagService tagService, - MachineTagService machineTagService, - CommentService commentService, - OccurrenceMappingService occurrenceMappingService, + PrimaryCollectionEntityService primaryCollectionEntityService, ChangeSuggestionService changeSuggestionService, DuplicatesService duplicatesService, Class objectClass) { - super( - objectClass, crudService, identifierService, tagService, machineTagService, commentService); + super(objectClass, primaryCollectionEntityService); this.mergeService = mergeService; this.changeSuggestionService = changeSuggestionService; - this.crudService = crudService; - this.contactService = contactService; - this.occurrenceMappingService = occurrenceMappingService; + this.primaryCollectionEntityService = primaryCollectionEntityService; this.duplicatesService = duplicatesService; } @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public UUID create(@RequestBody @Trim T entity) { - return crudService.create(entity); + return primaryCollectionEntityService.create(entity); } @PutMapping(value = "{key}", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public void update(@PathVariable("key") UUID key, @RequestBody @Trim T entity) { checkArgument(key.equals(entity.getKey())); - crudService.update(entity); + primaryCollectionEntityService.update(entity); } @PostMapping( value = "{key}/contact", consumes = {MediaType.APPLICATION_JSON_VALUE, MediaType.TEXT_PLAIN_VALUE}) public void addContact(@PathVariable("key") UUID entityKey, @RequestBody UUID personKey) { - contactService.addContact(entityKey, personKey); + primaryCollectionEntityService.addContact(entityKey, personKey); } @DeleteMapping("{key}/contact/{personKey}") public void removeContact(@PathVariable("key") UUID entityKey, @PathVariable UUID personKey) { - contactService.removeContact(entityKey, personKey); + primaryCollectionEntityService.removeContact(entityKey, personKey); } @GetMapping("{key}/contact") @Nullable public List listContacts(@PathVariable UUID key) { - return contactService.listContacts(key); + return primaryCollectionEntityService.listContacts(key); } @PostMapping(value = "{key}/occurrenceMapping", consumes = MediaType.APPLICATION_JSON_VALUE) @Trim public int addOccurrenceMapping( @PathVariable("key") UUID entityKey, @RequestBody @Trim OccurrenceMapping occurrenceMapping) { - return occurrenceMappingService.addOccurrenceMapping(entityKey, occurrenceMapping); + return primaryCollectionEntityService.addOccurrenceMapping(entityKey, occurrenceMapping); } @GetMapping("{key}/occurrenceMapping") @Nullable public List listOccurrenceMappings(@PathVariable("key") UUID uuid) { - return occurrenceMappingService.listOccurrenceMappings(uuid); + return primaryCollectionEntityService.listOccurrenceMappings(uuid); } @DeleteMapping("{key}/occurrenceMapping/{occurrenceMappingKey}") public void deleteOccurrenceMapping( @PathVariable("key") UUID entityKey, @PathVariable int occurrenceMappingKey) { - occurrenceMappingService.deleteOccurrenceMapping(entityKey, occurrenceMappingKey); + primaryCollectionEntityService.deleteOccurrenceMapping(entityKey, occurrenceMappingKey); } @PostMapping(value = "{key}/merge")