@PreAuthorize("hasRole('" + StandardEntitlement.DYNREALM_READ + "')") @Transactional(readOnly = true) public DynRealmTO read(final String key) { DynRealm dynRealm = dynRealmDAO.find(key); if (dynRealm == null) { LOG.error("Could not find dynamic realm '" + key + "'"); throw new NotFoundException(key); } return binder.getDynRealmTO(dynRealm); }
@Override public DynRealm update(final DynRealm toBeUpdated, final DynRealmTO dynRealmTO) { toBeUpdated.setKey(dynRealmTO.getKey()); DynRealm dynRealm = dynRealmDAO.save(toBeUpdated); for (Iterator<? extends DynRealmMembership> itor = dynRealm.getDynMemberships().iterator(); itor.hasNext();) { DynRealmMembership memb = itor.next(); memb.setDynRealm(null); itor.remove(); } dynRealmDAO.clearDynMembers(dynRealm); dynRealmTO.getDynMembershipConds().forEach((type, fiql) -> { AnyType anyType = anyTypeDAO.find(type); if (anyType == null) { LOG.warn("Ignoring invalid {}: {}", AnyType.class.getSimpleName(), type); } else { setDynMembership(dynRealm, anyType, fiql); } }); return dynRealmDAO.saveAndRefreshDynMemberships(dynRealm); }
@PreAuthorize("hasRole('" + StandardEntitlement.DYNREALM_DELETE + "')") public DynRealmTO delete(final String key) { DynRealm dynRealm = dynRealmDAO.find(key); if (dynRealm == null) { LOG.error("Could not find dynamic realm '" + key + "'"); throw new NotFoundException(key); } DynRealmTO deleted = binder.getDynRealmTO(dynRealm); dynRealmDAO.delete(key); return deleted; }
private Pair<AnyObject, Pair<Set<String>, Set<String>>> doSave(final AnyObject anyObject) { AnyObject merged = super.save(anyObject); publisher.publishEvent(new AnyCreatedUpdatedEvent<>(this, merged, AuthContextUtils.getDomain())); Pair<Set<String>, Set<String>> dynGroupMembs = groupDAO.refreshDynMemberships(merged); dynRealmDAO.refreshDynMemberships(merged); return Pair.of(merged, dynGroupMembs); }
@Override public void delete(final AnyObject anyObject) { groupDAO.removeDynMemberships(anyObject); dynRealmDAO.removeDynMemberships(anyObject.getKey()); findARelationships(anyObject).forEach(relationship -> { relationship.getLeftEnd().getRelationships().remove(relationship); save(relationship.getLeftEnd()); entityManager().remove(relationship); }); findURelationships(anyObject).forEach(relationship -> { relationship.getLeftEnd().getRelationships().remove(relationship); userDAO.save(relationship.getLeftEnd()); entityManager().remove(relationship); }); entityManager().remove(anyObject); publisher.publishEvent(new AnyDeletedEvent( this, AnyTypeKind.ANY_OBJECT, anyObject.getKey(), anyObject.getName(), AuthContextUtils.getDomain())); }
@Transactional(readOnly = true) public List<DynRealmTO> list() { return dynRealmDAO.findAll().stream().map(binder::getDynRealmTO).collect(Collectors.toList()); }
private Pair<User, Pair<Set<String>, Set<String>>> doSave(final User user) { // 1. save clear password value before save String clearPwd = user.getClearPassword(); // 2. save User merged = super.save(user); // 3. set back the sole clear password value JPAUser.class.cast(merged).setClearPassword(clearPwd); // 4. enforce password and account policies try { enforcePolicies(merged); } catch (InvalidEntityException e) { entityManager().remove(merged); throw e; } publisher.publishEvent(new AnyCreatedUpdatedEvent<>(this, merged, AuthContextUtils.getDomain())); roleDAO.refreshDynMemberships(merged); Pair<Set<String>, Set<String>> dynGroupMembs = groupDAO.refreshDynMemberships(merged); dynRealmDAO.refreshDynMemberships(merged); return Pair.of(merged, dynGroupMembs); }
@Override public void delete(final User user) { roleDAO.removeDynMemberships(user.getKey()); groupDAO.removeDynMemberships(user); dynRealmDAO.removeDynMemberships(user.getKey()); AccessToken accessToken = accessTokenDAO.findByOwner(user.getUsername()); if (accessToken != null) { accessTokenDAO.delete(accessToken); } entityManager().remove(user); publisher.publishEvent(new AnyDeletedEvent( this, AnyTypeKind.USER, user.getKey(), user.getUsername(), AuthContextUtils.getDomain())); }
@Transactional(readOnly = true) @Override @SuppressWarnings("unchecked") public List<String> findDynRealms(final String key) { Query query = entityManager().createNativeQuery( "SELECT dynRealm_id FROM " + JPADynRealmDAO.DYNMEMB_TABLE + " WHERE any_id=?"); query.setParameter(1, key); List<String> result = new ArrayList<>(); query.getResultList().stream().map(resultKey -> resultKey instanceof Object[] ? (String) ((Object[]) resultKey)[0] : ((String) resultKey)). forEachOrdered((actualKey) -> { DynRealm dynRealm = dynRealmDAO.find(actualKey.toString()); if (dynRealm == null) { LOG.error("Could not find dynRealm with id {}, even though returned by the native query", actualKey); } else if (!result.contains(actualKey.toString())) { result.add(actualKey.toString()); } }); return result; } }
dynRealmDAO.refreshDynMemberships(merged);
@Override public void delete(final Group group) { dynRealmDAO.removeDynMemberships(group.getKey());
DynRealm dynRealm = dynRealmDAO.find(realmPath); if (dynRealm == null) { LOG.warn("Ignoring invalid dynamic realm {}", realmPath);
@PreAuthorize("hasRole('" + StandardEntitlement.DYNREALM_UPDATE + "')") public DynRealmTO update(final DynRealmTO dynRealmTO) { DynRealm dynRealm = dynRealmDAO.find(dynRealmTO.getKey()); if (dynRealm == null) { LOG.error("Could not find dynamic realm '" + dynRealmTO.getKey() + "'"); throw new NotFoundException(dynRealmTO.getKey()); } return binder.getDynRealmTO(binder.update(dynRealm, dynRealmTO)); }
@Override protected DynRealmTO resolveReference(final Method method, final Object... args) throws UnresolvedReferenceException { String key = null; if (ArrayUtils.isNotEmpty(args)) { for (int i = 0; key == null && i < args.length; i++) { if (args[i] instanceof String) { key = (String) args[i]; } else if (args[i] instanceof DynRealmTO) { key = ((DynRealmTO) args[i]).getKey(); } } } if (key != null) { try { return binder.getDynRealmTO(dynRealmDAO.find(key)); } catch (Throwable ignore) { LOG.debug("Unresolved reference", ignore); throw new UnresolvedReferenceException(ignore); } } throw new UnresolvedReferenceException(); }
DynRealm dynRealm = dynRealmDAO.find(key); if (dynRealm == null) { LOG.debug("Invalid dynamic ream {}, ignoring", key);