From 55aecd9c579a0f4dde7a5e4e8f9e28553965f28a Mon Sep 17 00:00:00 2001 From: Thomas Georgios Giannos Date: Mon, 9 Oct 2023 11:17:16 +0300 Subject: [PATCH] Updating description template type controller with apropriate auditing and logging, added censor, refactored query building to conform with other projects workflows --- .../eu/eudat/model/censorship/BaseCensor.java | 23 ++++++ .../DescriptionTemplateTypeCensor.java | 28 +++++++ .../query/DescriptionTemplateTypeQuery.java | 18 +---- .../lookup/DescriptionTemplateTypeLookup.java | 12 +++ .../eu/eudat/query/lookup/LookupAware.java | 12 --- .../DescriptionTemplateTypeService.java | 37 ++++----- .../DescriptionTemplateTypeV2Controller.java | 76 +++++++++++++++++-- 7 files changed, 146 insertions(+), 60 deletions(-) create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/censorship/BaseCensor.java create mode 100644 dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java delete mode 100644 dmp-backend/core/src/main/java/eu/eudat/query/lookup/LookupAware.java diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/BaseCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/BaseCensor.java new file mode 100644 index 000000000..410848970 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/BaseCensor.java @@ -0,0 +1,23 @@ +package eu.eudat.model.censorship; + +import eu.eudat.convention.ConventionService; +import gr.cite.tools.data.censor.Censor; +import gr.cite.tools.fieldset.FieldSet; + +public class BaseCensor implements Censor { + + protected final ConventionService conventionService; + + public BaseCensor(ConventionService conventionService) { + this.conventionService = conventionService; + } + + protected Boolean isEmpty(FieldSet fields) { + return fields == null || fields.isEmpty(); + } + + protected String asIndexerPrefix(String part) { + return this.conventionService.asPrefix(part); + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java new file mode 100644 index 000000000..1b621ae12 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/model/censorship/DescriptionTemplateTypeCensor.java @@ -0,0 +1,28 @@ +package eu.eudat.model.censorship; + +import eu.eudat.convention.ConventionService; +import gr.cite.tools.fieldset.FieldSet; +import gr.cite.tools.logging.DataLogEntry; +import gr.cite.tools.logging.LoggerService; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; +import org.springframework.context.annotation.Scope; +import org.springframework.stereotype.Component; + +@Component +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +public class DescriptionTemplateTypeCensor extends BaseCensor{ + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeCensor.class)); + + public DescriptionTemplateTypeCensor(ConventionService conventionService) { + super(conventionService); + } + + public void censor(FieldSet fields) { + logger.debug(new DataLogEntry("censoring fields", fields)); + if (fields.isEmpty()) + return; + } + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java index f1f227312..48131e628 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/DescriptionTemplateTypeQuery.java @@ -1,9 +1,6 @@ package eu.eudat.query; -import eu.eudat.commons.enums.DescriptionTemplateTypeStatus; import eu.eudat.data.DescriptionTemplateTypeEntity; -import eu.eudat.query.lookup.DescriptionTemplateTypeLookup; -import eu.eudat.query.lookup.LookupAware; import gr.cite.tools.data.query.FieldResolver; import gr.cite.tools.data.query.QueryBase; import gr.cite.tools.data.query.QueryContext; @@ -18,7 +15,7 @@ import java.util.*; @Component @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) -public class DescriptionTemplateTypeQuery extends QueryBase implements LookupAware { +public class DescriptionTemplateTypeQuery extends QueryBase { private Collection ids; @@ -71,19 +68,6 @@ public class DescriptionTemplateTypeQuery extends QueryBase { - - /** - * Every query that supports building from a lookup object should implement this interface - * @param lookup The object containing all the lookup options - * @return The query built from all the set options - */ - Q fromLookup(L lookup); - -} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java index 9d2e5a95d..90e52d0bd 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java +++ b/dmp-backend/core/src/main/java/eu/eudat/service/DescriptionTemplateTypeService.java @@ -1,14 +1,14 @@ package eu.eudat.service; -import eu.eudat.audit.AuditableAction; import eu.eudat.commons.enums.DescriptionTemplateTypeStatus; import eu.eudat.data.DescriptionTemplateTypeEntity; import eu.eudat.model.DescriptionTemplateType; import eu.eudat.model.builder.DescriptionTemplateTypeBuilder; import eu.eudat.query.DescriptionTemplateTypeQuery; import eu.eudat.query.lookup.DescriptionTemplateTypeLookup; -import gr.cite.tools.auditing.AuditService; import gr.cite.tools.data.builder.BuilderFactory; +import gr.cite.tools.data.query.QueryFactory; +import gr.cite.tools.exception.MyNotFoundException; import jakarta.persistence.EntityManager; import jakarta.persistence.PersistenceContext; import org.springframework.context.ApplicationContext; @@ -28,44 +28,38 @@ public class DescriptionTemplateTypeService { private final BuilderFactory builderFactory; - private final PlatformTransactionManager transactionManager; + private final QueryFactory queryFactory; - private final AuditService auditService; + private final PlatformTransactionManager transactionManager; @PersistenceContext private EntityManager entityManager; - public DescriptionTemplateTypeService(ApplicationContext applicationContext, BuilderFactory builderFactory, PlatformTransactionManager platformTransactionManager, AuditService auditService) { + public DescriptionTemplateTypeService(ApplicationContext applicationContext, BuilderFactory builderFactory, QueryFactory queryFactory, PlatformTransactionManager platformTransactionManager) { this.applicationContext = applicationContext; this.builderFactory = builderFactory; + this.queryFactory = queryFactory; this.transactionManager = platformTransactionManager; - this.auditService = auditService; } public List query(DescriptionTemplateTypeLookup lookup) { - DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class); - List results = builderFactory - .builder(DescriptionTemplateTypeBuilder.class) - .build(lookup.getProject(), query.fromLookup(lookup).collect()); + DescriptionTemplateTypeQuery query = lookup.enrich(queryFactory); + List data = query.collectAs(lookup.getProject()); - auditService.track(AuditableAction.DescriptionTemplateType_Query, "lookup", lookup); - - return results; + return builderFactory.builder(DescriptionTemplateTypeBuilder.class).build(lookup.getProject(), data); } public DescriptionTemplateType get(UUID id) { DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class); - DescriptionTemplateType result = builderFactory + + return builderFactory .builder(DescriptionTemplateTypeBuilder.class) .build(null, query.ids(id).first()); - - auditService.track(AuditableAction.DescriptionTemplateType_Query, "id", id); - - return result; } public DescriptionTemplateTypeEntity getEntityByName(String name) { DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class); + return query.names(name).first(); } @@ -91,9 +85,8 @@ public class DescriptionTemplateTypeService { throw ex; } - auditService.track(AuditableAction.DescriptionTemplateType_Persist, "persist", payload); - DescriptionTemplateTypeQuery query = applicationContext.getBean(DescriptionTemplateTypeQuery.class); + return builderFactory .builder(DescriptionTemplateTypeBuilder.class) .build(null, query.ids(created.getId()).first()); @@ -106,8 +99,6 @@ public class DescriptionTemplateTypeService { entityManager.merge(entity); entityManager.flush(); - auditService.track(AuditableAction.DescriptionTemplateType_Persist, "update", payload); - return builderFactory.builder(DescriptionTemplateTypeBuilder.class).build(null, entity); } @@ -119,8 +110,6 @@ public class DescriptionTemplateTypeService { entityManager.merge(entity); entityManager.flush(); - auditService.track(AuditableAction.DescriptionTemplateType_Delete, "delete", id); - return true; } diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionTemplateTypeV2Controller.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionTemplateTypeV2Controller.java index c38d9c5c7..4eaae2942 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionTemplateTypeV2Controller.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/v2/DescriptionTemplateTypeV2Controller.java @@ -1,18 +1,31 @@ package eu.eudat.controllers.v2; +import eu.eudat.audit.AuditableAction; import eu.eudat.logic.security.claims.ClaimedAuthorities; import eu.eudat.model.DescriptionTemplateType; +import eu.eudat.model.censorship.DescriptionTemplateTypeCensor; import eu.eudat.model.result.QueryResult; import eu.eudat.models.data.security.Principal; import eu.eudat.query.lookup.DescriptionTemplateTypeLookup; import eu.eudat.service.DescriptionTemplateTypeService; import eu.eudat.types.Authorities; +import gr.cite.tools.auditing.AuditService; +import gr.cite.tools.data.censor.CensorFactory; +import gr.cite.tools.exception.MyNotFoundException; +import gr.cite.tools.fieldset.FieldSet; +import gr.cite.tools.logging.LoggerService; +import gr.cite.tools.logging.MapLogEntry; +import org.slf4j.LoggerFactory; +import org.springframework.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.bind.annotation.*; +import java.util.AbstractMap; +import java.util.Map; import java.util.UUID; import static eu.eudat.controllers.v2.BaseController.extractQueryResultWithCount; @@ -23,34 +36,83 @@ import static eu.eudat.controllers.v2.BaseController.extractQueryResultWithCount @RequestMapping(path = "api/v2/descriptionTemplateType", produces = MediaType.APPLICATION_JSON_VALUE) public class DescriptionTemplateTypeV2Controller { + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeV2Controller.class)); + + private final AuditService auditService; + private final DescriptionTemplateTypeService descriptionTemplateTypeService; - public DescriptionTemplateTypeV2Controller(DescriptionTemplateTypeService descriptionTemplateTypeService) { + private final MessageSource messageSource; + + private final CensorFactory censorFactory; + + public DescriptionTemplateTypeV2Controller(AuditService auditService, DescriptionTemplateTypeService descriptionTemplateTypeService, MessageSource messageSource, CensorFactory censorFactory) { + this.auditService = auditService; this.descriptionTemplateTypeService = descriptionTemplateTypeService; + this.messageSource = messageSource; + this.censorFactory = censorFactory; } @PostMapping("query") public QueryResult query(@RequestBody DescriptionTemplateTypeLookup lookup, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal ignoredPrincipal) { + logger.debug("querying {}", DescriptionTemplateType.class.getSimpleName()); + + censorFactory.censor(DescriptionTemplateTypeCensor.class).censor(lookup.getProject()); + + auditService.track(AuditableAction.DescriptionTemplateType_Query, "lookup", lookup); + return extractQueryResultWithCount(descriptionTemplateTypeService::query, lookup); } @GetMapping("{id}") - public QueryResult get(@PathVariable("id") UUID id, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal ignoredPrincipal) { - return new QueryResult<>(descriptionTemplateTypeService.get(id)); + public QueryResult get(@PathVariable("id") UUID id, FieldSet fieldSet, @ClaimedAuthorities(claims = {Authorities.ADMIN, Authorities.MANAGER, Authorities.USER, Authorities.ANONYMOUS}) Principal ignoredPrincipal) { + logger.debug(new MapLogEntry("retrieving" + DescriptionTemplateType.class.getSimpleName()).And("id", id)); + + censorFactory.censor(DescriptionTemplateTypeCensor.class).censor(fieldSet); + + DescriptionTemplateType model = descriptionTemplateTypeService.get(id); + if (model == null) + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, DescriptionTemplateType.class.getSimpleName()}, LocaleContextHolder.getLocale())); + + auditService.track(AuditableAction.DescriptionTemplateType_Query, "id", id); + + return new QueryResult<>(model); } @PostMapping("persist") - public QueryResult persist(@RequestBody DescriptionTemplateType payload, @ClaimedAuthorities(claims = {Authorities.ADMIN}) Principal ignoredPrincipal) { - return new QueryResult<>(descriptionTemplateTypeService.persist(payload)); + public QueryResult persist(@RequestBody DescriptionTemplateType payload, FieldSet fieldSet, @ClaimedAuthorities(claims = {Authorities.ADMIN}) Principal ignoredPrincipal) { + logger.debug(new MapLogEntry("persisting" + DescriptionTemplateType.class.getSimpleName()).And("model", payload).And("fieldSet", fieldSet)); + + DescriptionTemplateType persisted = descriptionTemplateTypeService.persist(payload); + + auditService.track(AuditableAction.DescriptionTemplateType_Persist, Map.ofEntries( + new AbstractMap.SimpleEntry("model", payload), + new AbstractMap.SimpleEntry("fields", fieldSet) + )); + + return new QueryResult<>(persisted); } @PostMapping("update") - public QueryResult update(@RequestBody DescriptionTemplateType payload, @ClaimedAuthorities(claims = {Authorities.ADMIN}) Principal ignoredPrincipal) { - return new QueryResult<>(descriptionTemplateTypeService.update(payload)); + public QueryResult update(@RequestBody DescriptionTemplateType payload, FieldSet fieldSet, @ClaimedAuthorities(claims = {Authorities.ADMIN}) Principal ignoredPrincipal) { + logger.debug(new MapLogEntry("persisting" + DescriptionTemplateType.class.getSimpleName()).And("model", payload).And("fieldSet", fieldSet)); + + DescriptionTemplateType persisted = descriptionTemplateTypeService.update(payload); + + auditService.track(AuditableAction.DescriptionTemplateType_Persist, Map.ofEntries( + new AbstractMap.SimpleEntry("model", payload), + new AbstractMap.SimpleEntry("fields", fieldSet) + )); + + return new QueryResult<>(persisted); } @DeleteMapping("delete/{id}") public ResponseEntity delete(@PathVariable(value = "id") UUID id, @ClaimedAuthorities(claims = {Authorities.ADMIN}) Principal ignoredPrincipal) { + logger.debug(new MapLogEntry("deleting" + DescriptionTemplateType.class.getSimpleName()).And("id", id)); + + auditService.track(AuditableAction.DescriptionTemplateType_Delete, "delete", id); + if (descriptionTemplateTypeService.delete(id)) return ResponseEntity.status(HttpStatus.OK).build(); else