diff --git a/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java b/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java index d400b79c0..447a8da61 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java +++ b/dmp-backend/core/src/main/java/eu/eudat/audit/AuditableAction.java @@ -162,5 +162,10 @@ public class AuditableAction { public static final EventId PrefillingSource_Delete = new EventId(260003, "PrefillingSource_Delete"); public static final EventId PrefillingSource_Generate = new EventId(260004, "PrefillingSource_Generate"); + public static final EventId TenantConfiguration_Query = new EventId(270000, "TenantConfiguration_Query"); + public static final EventId TenantConfiguration_Lookup = new EventId(270001, "TenantConfiguration_Lookup"); + public static final EventId TenantConfiguration_Persist = new EventId(270002, "TenantConfiguration_Persist"); + public static final EventId TenantConfiguration_Delete = new EventId(270003, "TenantConfiguration_Delete"); + } diff --git a/dmp-backend/core/src/main/java/eu/eudat/errorcode/ErrorThesaurusProperties.java b/dmp-backend/core/src/main/java/eu/eudat/errorcode/ErrorThesaurusProperties.java index 23cc87410..f3e518eff 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/errorcode/ErrorThesaurusProperties.java +++ b/dmp-backend/core/src/main/java/eu/eudat/errorcode/ErrorThesaurusProperties.java @@ -174,4 +174,14 @@ public class ErrorThesaurusProperties { public void setTenantTampering(ErrorDescription tenantTampering) { this.tenantTampering = tenantTampering; } + + private ErrorDescription tenantConfigurationTypeCanNotChange; + + public ErrorDescription getTenantConfigurationTypeCanNotChange() { + return tenantConfigurationTypeCanNotChange; + } + + public void setTenantConfigurationTypeCanNotChange(ErrorDescription tenantConfigurationTypeCanNotChange) { + this.tenantConfigurationTypeCanNotChange = tenantConfigurationTypeCanNotChange; + } } diff --git a/dmp-backend/core/src/main/java/eu/eudat/model/builder/tenantconfiguration/TenantConfigurationBuilder.java b/dmp-backend/core/src/main/java/eu/eudat/model/builder/tenantconfiguration/TenantConfigurationBuilder.java index 50a636a9d..6d0c22672 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/model/builder/tenantconfiguration/TenantConfigurationBuilder.java +++ b/dmp-backend/core/src/main/java/eu/eudat/model/builder/tenantconfiguration/TenantConfigurationBuilder.java @@ -36,7 +36,7 @@ public class TenantConfigurationBuilder extends BaseBuilder ids = data.stream().map(TenantEntity::getId).distinct().collect(Collectors.toList()); + { + logger.debug("checking related - {}", TenantConfigurationEntity.class.getSimpleName()); + List items = this.queryFactory.query(TenantConfigurationQuery.class).tenantIds(ids).collect(); + TenantConfigurationDeleter deleter = this.deleterFactory.deleter(TenantConfigurationDeleter.class); + deleter.delete(items); + } + Instant now = Instant.now(); for (TenantEntity item : data) { diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/TenantConfigurationQuery.java b/dmp-backend/core/src/main/java/eu/eudat/query/TenantConfigurationQuery.java index 2baed8d7d..8dce7d98e 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/TenantConfigurationQuery.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/TenantConfigurationQuery.java @@ -6,7 +6,6 @@ import eu.eudat.commons.enums.IsActive; import eu.eudat.commons.enums.TenantConfigurationType; import eu.eudat.data.TenantConfigurationEntity; import eu.eudat.model.tenantconfiguration.TenantConfiguration; -import eu.eudat.query.utils.QueryUtilsService; import gr.cite.tools.data.query.FieldResolver; import gr.cite.tools.data.query.QueryBase; import gr.cite.tools.data.query.QueryContext; @@ -25,16 +24,15 @@ import java.util.*; public class TenantConfigurationQuery extends QueryBase { private Collection ids; + private Collection tenantIds; + private Boolean tenantIsSet; private Collection isActives; private Collection types; private Collection excludedIds; private EnumSet authorize = EnumSet.of(AuthorizationFlags.None); - private final QueryUtilsService queryUtilsService; - - public TenantConfigurationQuery(QueryUtilsService queryUtilsService) { - this.queryUtilsService = queryUtilsService; + public TenantConfigurationQuery() { } public TenantConfigurationQuery ids(UUID value) { @@ -52,6 +50,26 @@ public class TenantConfigurationQuery extends QueryBase values) { + this.tenantIds = values; + return this; + } + + public TenantConfigurationQuery tenantIsSet(Boolean values) { + this.tenantIsSet = values; + return this; + } + public TenantConfigurationQuery isActive(IsActive value) { this.isActives = List.of(value); return this; @@ -104,7 +122,7 @@ public class TenantConfigurationQuery extends QueryBase inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(TenantConfigurationEntity._tenantId)); + for (UUID item : this.tenantIds) inClause.value(item); + predicates.add(inClause); + } if (this.isActives != null) { CriteriaBuilder.In inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(TenantConfigurationEntity._isActive)); @@ -128,6 +151,12 @@ public class TenantConfigurationQuery extends QueryBase inClause = queryContext.CriteriaBuilder.in(queryContext.Root.get(TenantConfigurationEntity._type)); diff --git a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/TenantConfigurationLookup.java b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/TenantConfigurationLookup.java index 3ac81a423..b29d160a3 100644 --- a/dmp-backend/core/src/main/java/eu/eudat/query/lookup/TenantConfigurationLookup.java +++ b/dmp-backend/core/src/main/java/eu/eudat/query/lookup/TenantConfigurationLookup.java @@ -14,7 +14,9 @@ public class TenantConfigurationLookup extends Lookup { private List isActive; private List types; private List ids; + private List tenantIds; private List excludedIds; + private Boolean tenantIsSet; public List getIsActive() { @@ -55,6 +57,8 @@ public class TenantConfigurationLookup extends Lookup { if (this.isActive != null) query.isActive(this.isActive); if (this.ids != null) query.ids(this.ids); if (this.excludedIds != null) query.excludedIds(this.excludedIds); + if (this.tenantIds != null) query.tenantIds(this.tenantIds); + if (this.tenantIsSet != null) query.tenantIsSet(this.tenantIsSet); this.enrichCommon(query); diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationService.java b/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationService.java new file mode 100644 index 000000000..686f6c6f0 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationService.java @@ -0,0 +1,21 @@ +package eu.eudat.service.tenantconfiguration; + +import com.fasterxml.jackson.core.JsonProcessingException; +import eu.eudat.model.persist.tenantconfiguration.TenantConfigurationPersist; +import eu.eudat.model.tenantconfiguration.TenantConfiguration; +import gr.cite.tools.exception.MyApplicationException; +import gr.cite.tools.exception.MyForbiddenException; +import gr.cite.tools.exception.MyNotFoundException; +import gr.cite.tools.exception.MyValidationException; +import gr.cite.tools.fieldset.FieldSet; + +import javax.management.InvalidApplicationException; +import java.util.UUID; + +public interface TenantConfigurationService { + + TenantConfiguration persist(TenantConfigurationPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, JsonProcessingException; + + void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException; + +} diff --git a/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationServiceImpl.java b/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationServiceImpl.java new file mode 100644 index 000000000..680cf1f61 --- /dev/null +++ b/dmp-backend/core/src/main/java/eu/eudat/service/tenantconfiguration/TenantConfigurationServiceImpl.java @@ -0,0 +1,210 @@ +package eu.eudat.service.tenantconfiguration; + +import com.fasterxml.jackson.core.JsonProcessingException; +import eu.eudat.authorization.AuthorizationFlags; +import eu.eudat.authorization.Permission; +import eu.eudat.commons.JsonHandlingService; +import eu.eudat.commons.enums.EntityType; +import eu.eudat.commons.enums.IsActive; +import eu.eudat.commons.types.deposit.DepositSourceEntity; +import eu.eudat.commons.types.dmp.DmpPropertiesEntity; +import eu.eudat.commons.types.filetransformer.FileTransformerSourceEntity; +import eu.eudat.commons.types.tenantconfiguration.*; +import eu.eudat.convention.ConventionService; +import eu.eudat.data.TenantConfigurationEntity; +import eu.eudat.data.TenantEntityManager; +import eu.eudat.errorcode.ErrorThesaurusProperties; +import eu.eudat.model.builder.tenantconfiguration.TenantConfigurationBuilder; +import eu.eudat.model.deleter.TenantConfigurationDeleter; +import eu.eudat.model.persist.deposit.DepositSourcePersist; +import eu.eudat.model.persist.dmpproperties.DmpBlueprintValuePersist; +import eu.eudat.model.persist.dmpproperties.DmpContactPersist; +import eu.eudat.model.persist.dmpproperties.DmpPropertiesPersist; +import eu.eudat.model.persist.filetransformer.FileTransformerSourcePersist; +import eu.eudat.model.persist.tenantconfiguration.*; +import eu.eudat.model.tenantconfiguration.TenantConfiguration; +import gr.cite.commons.web.authz.service.AuthorizationService; +import gr.cite.tools.data.builder.BuilderFactory; +import gr.cite.tools.data.deleter.DeleterFactory; +import gr.cite.tools.exception.MyApplicationException; +import gr.cite.tools.exception.MyForbiddenException; +import gr.cite.tools.exception.MyNotFoundException; +import gr.cite.tools.exception.MyValidationException; +import gr.cite.tools.fieldset.BaseFieldSet; +import gr.cite.tools.fieldset.FieldSet; +import gr.cite.tools.logging.LoggerService; +import gr.cite.tools.logging.MapLogEntry; +import org.jetbrains.annotations.NotNull; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.MessageSource; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.stereotype.Service; + +import javax.management.InvalidApplicationException; +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +@Service +public class TenantConfigurationServiceImpl implements TenantConfigurationService { + + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantConfigurationServiceImpl.class)); + + private final TenantEntityManager entityManager; + + private final AuthorizationService authorizationService; + + private final DeleterFactory deleterFactory; + + private final BuilderFactory builderFactory; + + private final ConventionService conventionService; + + private final ErrorThesaurusProperties errors; + + private final MessageSource messageSource; + + private final JsonHandlingService jsonHandlingService; + + + @Autowired + public TenantConfigurationServiceImpl( + TenantEntityManager entityManager, + AuthorizationService authorizationService, + DeleterFactory deleterFactory, + BuilderFactory builderFactory, + ConventionService conventionService, + ErrorThesaurusProperties errors, + MessageSource messageSource, JsonHandlingService jsonHandlingService) { + this.entityManager = entityManager; + this.authorizationService = authorizationService; + this.deleterFactory = deleterFactory; + this.builderFactory = builderFactory; + this.conventionService = conventionService; + this.errors = errors; + this.messageSource = messageSource; + this.jsonHandlingService = jsonHandlingService; + } + + public TenantConfiguration persist(TenantConfigurationPersist model, FieldSet fields) throws MyForbiddenException, MyValidationException, MyApplicationException, MyNotFoundException, InvalidApplicationException, JsonProcessingException { + logger.debug(new MapLogEntry("persisting data TenantConfiguration").And("model", model).And("fields", fields)); + + this.authorizationService.authorizeForce(Permission.EditTenantConfiguration); + + Boolean isUpdate = this.conventionService.isValidGuid(model.getId()); + + TenantConfigurationEntity data; + if (isUpdate) { + data = this.entityManager.find(TenantConfigurationEntity.class, model.getId()); + if (data == null) throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{model.getId(), TenantConfiguration.class.getSimpleName()}, LocaleContextHolder.getLocale())); + if (!this.conventionService.hashValue(data.getUpdatedAt()).equals(model.getHash())) throw new MyValidationException(this.errors.getHashConflict().getCode(), this.errors.getHashConflict().getMessage()); + if (!data.getType().equals(model.getType())) throw new MyValidationException(this.errors.getTenantConfigurationTypeCanNotChange().getCode(), this.errors.getTenantConfigurationTypeCanNotChange().getMessage()); + } else { + data = new TenantConfigurationEntity(); + data.setId(UUID.randomUUID()); + data.setIsActive(IsActive.Active); + data.setCreatedAt(Instant.now()); + data.setType(model.getType()); + } + + switch (data.getType()){ + case CssColors -> data.setValue(this.jsonHandlingService.toJson(this.buildCssColorsTenantConfigurationEntity(model.getCssColors()))); + case DefaultUserLocale -> data.setValue(this.jsonHandlingService.toJson(this.buildDefaultUserLocaleTenantConfigurationEntity(model.getDefaultUserLocale()))); + case DepositPlugins -> data.setValue(this.jsonHandlingService.toJson(this.buildDepositTenantConfigurationEntity(model.getDepositPlugins()))); + case FileTransformerPlugins -> data.setValue(this.jsonHandlingService.toJson(this.buildFileTransformerTenantConfigurationEntity(model.getFileTransformerPlugins()))); + case Logo -> data.setValue(this.jsonHandlingService.toJson(this.buildLogoTenantConfigurationEntity(model.getLogo()))); + default -> throw new InternalError("unknown type: " + data.getType()); + } + data.setUpdatedAt(Instant.now()); + if (isUpdate) + this.entityManager.merge(data); + else + this.entityManager.persist(data); + + this.entityManager.flush(); + + return this.builderFactory.builder(TenantConfigurationBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).build(BaseFieldSet.build(fields, TenantConfiguration._id), data); + } + + private @NotNull DepositTenantConfigurationEntity buildDepositTenantConfigurationEntity(DepositTenantConfigurationPersist persist){ + DepositTenantConfigurationEntity data = new DepositTenantConfigurationEntity(); + if (persist == null || this.conventionService.isListNullOrEmpty(persist.getSources())) return data; + data.setSources(new ArrayList<>()); + for (DepositSourcePersist depositSourcePersist : persist.getSources()) { + data.getSources().add(this.buildDepositSourceEntity(depositSourcePersist)); + } + return data; + } + + private DepositSourceEntity buildDepositSourceEntity(DepositSourcePersist depositSourcePersist) { + DepositSourceEntity depositSourceEntity = new DepositSourceEntity(); + depositSourceEntity.setClientId(depositSourcePersist.getClientId()); + depositSourceEntity.setClientSecret(depositSourcePersist.getClientSecret()); + depositSourceEntity.setRepositoryId(depositSourcePersist.getRepositoryId()); + depositSourceEntity.setUrl(depositSourcePersist.getUrl()); + depositSourceEntity.setIssuerUrl(depositSourcePersist.getIssuerUrl()); + depositSourceEntity.setScope(depositSourcePersist.getScope()); + depositSourceEntity.setPdfTransformerId(depositSourcePersist.getPdfTransformerId()); + depositSourceEntity.setRdaTransformerId(depositSourcePersist.getRdaTransformerId()); + return depositSourceEntity; + } + + private @NotNull FileTransformerTenantConfigurationEntity buildFileTransformerTenantConfigurationEntity(FileTransformerTenantConfigurationPersist persist){ + FileTransformerTenantConfigurationEntity data = new FileTransformerTenantConfigurationEntity(); + if (persist == null || this.conventionService.isListNullOrEmpty(persist.getSources())) return data; + data.setSources(new ArrayList<>()); + for (FileTransformerSourcePersist depositSourcePersist : persist.getSources()) { + data.getSources().add(this.buildFileTransformerSourceEntity(depositSourcePersist)); + } + return data; + } + + private FileTransformerSourceEntity buildFileTransformerSourceEntity(FileTransformerSourcePersist depositSourcePersist) { + FileTransformerSourceEntity depositSourceEntity = new FileTransformerSourceEntity(); + depositSourceEntity.setClientId(depositSourcePersist.getClientId()); + depositSourceEntity.setClientSecret(depositSourcePersist.getClientSecret()); + depositSourceEntity.setUrl(depositSourcePersist.getUrl()); + depositSourceEntity.setIssuerUrl(depositSourcePersist.getIssuerUrl()); + depositSourceEntity.setScope(depositSourcePersist.getScope()); + depositSourceEntity.setTransformerId(depositSourcePersist.getTransformerId()); + return depositSourceEntity; + } + + private @NotNull CssColorsTenantConfigurationEntity buildCssColorsTenantConfigurationEntity(CssColorsTenantConfigurationPersist persist){ + CssColorsTenantConfigurationEntity data = new CssColorsTenantConfigurationEntity(); + if (persist == null) return data; + data.setPrimaryColor(persist.getPrimaryColor()); + data.setPrimaryColor2(persist.getPrimaryColor2()); + data.setPrimaryColor3(persist.getPrimaryColor3()); + data.setSecondaryColor(persist.getSecondaryColor()); + return data; + } + + private @NotNull DefaultUserLocaleTenantConfigurationEntity buildDefaultUserLocaleTenantConfigurationEntity(DefaultUserLocaleTenantConfigurationPersist persist){ + DefaultUserLocaleTenantConfigurationEntity data = new DefaultUserLocaleTenantConfigurationEntity(); + if (persist == null) return data; + data.setCulture(persist.getCulture()); + data.setLanguage(persist.getLanguage()); + data.setTimezone(persist.getTimezone()); + return data; + } + + private @NotNull LogoTenantConfigurationEntity buildLogoTenantConfigurationEntity(LogoTenantConfigurationPersist persist){ + LogoTenantConfigurationEntity data = new LogoTenantConfigurationEntity(); + if (persist == null) return data; + data.setStorageFileId(persist.getStorageFileId()); + //TODO + return data; + } + + public void deleteAndSave(UUID id) throws MyForbiddenException, InvalidApplicationException { + logger.debug("deleting dataset: {}", id); + + this.authorizationService.authorizeForce(Permission.DeleteTenantConfiguration); + + this.deleterFactory.deleter(TenantConfigurationDeleter.class).deleteAndSaveByIds(List.of(id)); + } + +} diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/EntityDoiController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/EntityDoiController.java index 156339675..be56098f1 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/EntityDoiController.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/EntityDoiController.java @@ -37,7 +37,7 @@ import java.util.*; @RequestMapping(path = "api/entity-doi") public class EntityDoiController { - private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeController.class)); + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(EntityDoiController.class)); private final BuilderFactory builderFactory; diff --git a/dmp-backend/web/src/main/java/eu/eudat/controllers/TenantConfigurationController.java b/dmp-backend/web/src/main/java/eu/eudat/controllers/TenantConfigurationController.java index 156339675..e7425cca0 100644 --- a/dmp-backend/web/src/main/java/eu/eudat/controllers/TenantConfigurationController.java +++ b/dmp-backend/web/src/main/java/eu/eudat/controllers/TenantConfigurationController.java @@ -1,19 +1,18 @@ package eu.eudat.controllers; +import com.fasterxml.jackson.core.JsonProcessingException; import eu.eudat.audit.AuditableAction; import eu.eudat.authorization.AuthorizationFlags; -import gr.cite.tools.validation.ValidationFilterAnnotation; -import eu.eudat.data.EntityDoiEntity; +import eu.eudat.data.TenantConfigurationEntity; import eu.eudat.model.DescriptionTemplateType; -import eu.eudat.model.EntityDoi; -import eu.eudat.model.builder.EntityDoiBuilder; -import eu.eudat.model.censorship.EntityDoiCensor; -import eu.eudat.model.persist.EntityDoiPersist; +import eu.eudat.model.builder.tenantconfiguration.TenantConfigurationBuilder; +import eu.eudat.model.censorship.tenantconfiguration.TenantConfigurationCensor; +import eu.eudat.model.persist.tenantconfiguration.TenantConfigurationPersist; import eu.eudat.model.result.QueryResult; -import eu.eudat.query.EntityDoiQuery; -import eu.eudat.query.lookup.EntityDoiLookup; -import eu.eudat.service.deposit.DepositService; -import eu.eudat.service.entitydoi.EntityDoiService; +import eu.eudat.model.tenantconfiguration.TenantConfiguration; +import eu.eudat.query.TenantConfigurationQuery; +import eu.eudat.query.lookup.TenantConfigurationLookup; +import eu.eudat.service.tenantconfiguration.TenantConfigurationService; import gr.cite.tools.auditing.AuditService; import gr.cite.tools.data.builder.BuilderFactory; import gr.cite.tools.data.censor.CensorFactory; @@ -24,6 +23,7 @@ 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 gr.cite.tools.validation.ValidationFilterAnnotation; import org.slf4j.LoggerFactory; import org.springframework.context.MessageSource; import org.springframework.context.i18n.LocaleContextHolder; @@ -34,16 +34,16 @@ import javax.management.InvalidApplicationException; import java.util.*; @RestController -@RequestMapping(path = "api/entity-doi") -public class EntityDoiController { +@RequestMapping(path = "api/tenant-configuration") +public class TenantConfigurationController { - private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(DescriptionTemplateTypeController.class)); + private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantConfigurationController.class)); private final BuilderFactory builderFactory; private final AuditService auditService; - private final EntityDoiService entityDoiService; + private final TenantConfigurationService tenantConfigurationService; private final CensorFactory censorFactory; @@ -51,49 +51,49 @@ public class EntityDoiController { private final MessageSource messageSource; - public EntityDoiController( + public TenantConfigurationController( BuilderFactory builderFactory, AuditService auditService, - EntityDoiService entityDoiService, CensorFactory censorFactory, + TenantConfigurationService tenantConfigurationService, CensorFactory censorFactory, QueryFactory queryFactory, MessageSource messageSource) { this.builderFactory = builderFactory; this.auditService = auditService; - this.entityDoiService = entityDoiService; + this.tenantConfigurationService = tenantConfigurationService; this.censorFactory = censorFactory; this.queryFactory = queryFactory; this.messageSource = messageSource; } @PostMapping("query") - public QueryResult Query(@RequestBody EntityDoiLookup lookup) throws MyApplicationException, MyForbiddenException { - logger.debug("querying {}", EntityDoi.class.getSimpleName()); + public QueryResult Query(@RequestBody TenantConfigurationLookup lookup) throws MyApplicationException, MyForbiddenException { + logger.debug("querying {}", TenantConfiguration.class.getSimpleName()); - this.censorFactory.censor(EntityDoiCensor.class).censor(lookup.getProject(), null); + this.censorFactory.censor(TenantConfigurationCensor.class).censor(lookup.getProject(), null); - EntityDoiQuery query = lookup.enrich(this.queryFactory).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission); + TenantConfigurationQuery query = lookup.enrich(this.queryFactory).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission); - List data = query.collectAs(lookup.getProject()); - List models = this.builderFactory.builder(EntityDoiBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).build(lookup.getProject(), data); + List data = query.collectAs(lookup.getProject()); + List models = this.builderFactory.builder(TenantConfigurationBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).build(lookup.getProject(), data); long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size(); - this.auditService.track(AuditableAction.EntityDoi_Query, "lookup", lookup); + this.auditService.track(AuditableAction.TenantConfiguration_Query, "lookup", lookup); return new QueryResult<>(models, count); } @GetMapping("{id}") - public EntityDoi Get(@PathVariable("id") UUID id, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException { - logger.debug(new MapLogEntry("retrieving" + EntityDoi.class.getSimpleName()).And("id", id).And("fields", fieldSet)); + public TenantConfiguration Get(@PathVariable("id") UUID id, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException { + logger.debug(new MapLogEntry("retrieving" + TenantConfiguration.class.getSimpleName()).And("id", id).And("fields", fieldSet)); - this.censorFactory.censor(EntityDoiCensor.class).censor(fieldSet, null); + this.censorFactory.censor(TenantConfigurationCensor.class).censor(fieldSet, null); - EntityDoiQuery query = this.queryFactory.query(EntityDoiQuery.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).ids(id); - EntityDoi model = this.builderFactory.builder(EntityDoiBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).build(fieldSet, query.firstAs(fieldSet)); + TenantConfigurationQuery query = this.queryFactory.query(TenantConfigurationQuery.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).ids(id); + TenantConfiguration model = this.builderFactory.builder(TenantConfigurationBuilder.class).authorize(AuthorizationFlags.OwnerOrDmpAssociatedOrPermission).build(fieldSet, query.firstAs(fieldSet)); if (model == null) - throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, EntityDoi.class.getSimpleName()}, LocaleContextHolder.getLocale())); + throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, TenantConfiguration.class.getSimpleName()}, LocaleContextHolder.getLocale())); - this.auditService.track(AuditableAction.EntityDoi_Lookup, Map.ofEntries( + this.auditService.track(AuditableAction.TenantConfiguration_Lookup, Map.ofEntries( new AbstractMap.SimpleEntry("id", id), new AbstractMap.SimpleEntry("fields", fieldSet) )); @@ -103,12 +103,12 @@ public class EntityDoiController { @PostMapping("persist") @Transactional - @ValidationFilterAnnotation(validator = EntityDoiPersist.EntityDoiPersistValidator.ValidatorName, argumentName = "model") - public EntityDoi Persist(@RequestBody EntityDoiPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException, InvalidApplicationException { + @ValidationFilterAnnotation(validator = TenantConfigurationPersist.TenantConfigurationPersistValidator.ValidatorName, argumentName = "model") + public TenantConfiguration Persist(@RequestBody TenantConfigurationPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException, InvalidApplicationException, JsonProcessingException { logger.debug(new MapLogEntry("persisting" + DescriptionTemplateType.class.getSimpleName()).And("model", model).And("fieldSet", fieldSet)); - EntityDoi persisted = this.entityDoiService.persist(model, fieldSet); + TenantConfiguration persisted = this.tenantConfigurationService.persist(model, fieldSet); - this.auditService.track(AuditableAction.EntityDoi_Persist, Map.ofEntries( + this.auditService.track(AuditableAction.TenantConfiguration_Persist, Map.ofEntries( new AbstractMap.SimpleEntry("model", model), new AbstractMap.SimpleEntry("fields", fieldSet) )); @@ -119,11 +119,11 @@ public class EntityDoiController { @DeleteMapping("{id}") @Transactional public void Delete(@PathVariable("id") UUID id) throws MyForbiddenException, InvalidApplicationException { - logger.debug(new MapLogEntry("retrieving" + EntityDoi.class.getSimpleName()).And("id", id)); + logger.debug(new MapLogEntry("retrieving" + TenantConfiguration.class.getSimpleName()).And("id", id)); - this.entityDoiService.deleteAndSave(id); + this.tenantConfigurationService.deleteAndSave(id); - this.auditService.track(AuditableAction.EntityDoi_Delete, "id", id); + this.auditService.track(AuditableAction.TenantConfiguration_Delete, "id", id); } } diff --git a/dmp-backend/web/src/main/resources/config/errors.yml b/dmp-backend/web/src/main/resources/config/errors.yml index 6b3580195..7cdda0db9 100644 --- a/dmp-backend/web/src/main/resources/config/errors.yml +++ b/dmp-backend/web/src/main/resources/config/errors.yml @@ -59,3 +59,7 @@ error-thesaurus: tenant-tampering: code: 123 message: Tenant tampering + tenant-configuration-type-can-not-change: + code: 124 + message: Tenant configuration type can not change +