/** * Tries to save the passed list of {@link VOUdaDefinition}s. Checks if the passed values are * valid and permitted to be accessed. * * @param defs the {@link VOUdaDefinition}s to save * @param caller the calling (owning) {@link Organization} * @throws ValidationException in case of an invalid {@link VOUdaDefinition} * @throws OrganizationAuthoritiesException in case the calling {@link Organization} has * insufficient roles to create {@link UdaDefinition}s of the set {@link UdaTargetType}. * @throws NonUniqueBusinessKeyException in case a {@link UdaDefinition} with the passed id and * target type already exists for the owning {@link Organization} * @throws OperationNotPermittedException in case it was tries to update a {@link UdaDefinition} * owned by another {@link Organization}. * @throws ConcurrentModificationException in case the {@link UdaDefinition} to update was * concurrently changed * @throws ObjectNotFoundException in case on of the {@link UdaDefinition}s to update was not * found */ public void saveUdaDefinitions(List<VOUdaDefinition> defs, Organization caller) throws ValidationException, OrganizationAuthoritiesException, NonUniqueBusinessKeyException, OperationNotPermittedException, ConcurrentModificationException, ObjectNotFoundException { for (VOUdaDefinition voDef : defs) { // convert and validate UdaDefinition def; try { def = UdaAssembler.toUdaDefinition(voDef); def.setOrganization(caller); } catch (ValidationException e) { logger.logWarn( Log4jLogger.SYSTEM_LOG, e, LogMessageIdentifier.WARN_INVALID_UDA_DEFINITION, voDef.getUdaId()); ctx.setRollbackOnly(); throw e; } // check if target type is allowed for organization UdaTargetType type = def.getTargetType(); if (!type.canSaveDefinition(caller.getGrantedRoleTypes())) { String roles = rolesToString(type.getRoles()); OrganizationAuthoritiesException e = new OrganizationAuthoritiesException( "Insufficient authorization. Required role(s) '" + roles + "'.", new Object[] {roles}); logger.logWarn( Log4jLogger.SYSTEM_LOG | Log4jLogger.AUDIT_LOG, e, LogMessageIdentifier.WARN_ORGANIZATION_ROLE_REQUIRED, Long.toString(caller.getKey()), roles); ctx.setRollbackOnly(); throw e; } if (voDef.getKey() > 0) { updateDefinition(voDef, caller); } else { createDefinition(def); } UdaDefinition storedUda = (UdaDefinition) ds.find(def); if (storedUda == null) { return; } storeLocalizedAttributeName(storedUda.getKey(), voDef.getName(), voDef.getLanguage()); } }
/** * Updates an existing {@link UdaDefinition} - if it was not found, nothing will be done. Checks * if the caller is the owner, performs business key uniqueness check if the id has changed and * validates the passed {@link VOUdaDefinition}. * * @param voDef the updated {@link VOUdaDefinition} * @param owner the owning {@link Organization} * @throws OperationNotPermittedException in case the calling {@link Organization} is not the * owner * @throws ValidationException in case the passed {@link VOUdaDefinition} is invalid * @throws ConcurrentModificationException in case the {@link UdaDefinition} to update has been * changed concurrently * @throws NonUniqueBusinessKeyException in case the change leads to a non-unique business key * @throws ObjectNotFoundException in case the {@link UdaDefinition} to update was not found */ void updateDefinition(VOUdaDefinition voDef, Organization owner) throws OperationNotPermittedException, ValidationException, ConcurrentModificationException, NonUniqueBusinessKeyException, ObjectNotFoundException { UdaDefinition existing = ds.getReference(UdaDefinition.class, voDef.getKey()); PermissionCheck.owns(existing, owner, logger, ctx); // target type and encryption flag must not be changed as it will cause // inconsistencies for all depending UDAs voDef.setTargetType(existing.getTargetType().name()); voDef.setEncrypted(existing.isEncrypted()); // verify business key uniqueness UdaDefinition tempForUniquenessCheck = null; tempForUniquenessCheck = UdaAssembler.toUdaDefinition(voDef); tempForUniquenessCheck.setOrganization(owner); tempForUniquenessCheck.setKey(existing.getKey()); try { ds.validateBusinessKeyUniqueness(tempForUniquenessCheck); UdaAssembler.updateUdaDefinition(existing, voDef); } catch (NonUniqueBusinessKeyException e) { logger.logWarn( Log4jLogger.SYSTEM_LOG, e, LogMessageIdentifier.WARN_NON_UNIQUE_BUSINESS_KEY_UDA_DEFINITION); ctx.setRollbackOnly(); throw e; } }