public void populate() { dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(BACKEND, POSTGRESQL) .findAll() .forEach(entityTypeRegistry::registerEntityType); } }
@Transactional(readOnly = true) @Override public List<Resource> getResources(@Nullable String folderId) { try (Stream<Resource> packageResources = dataService .query(PackageMetadata.PACKAGE, Package.class) .eq(PackageMetadata.PARENT, folderId) .findAll() .map(this::toResource)) { Stream<Resource> entityTypeResources = dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(EntityTypeMetadata.PACKAGE, folderId) .findAll() .map(this::toResource); return Streams.concat(packageResources, entityTypeResources).collect(toList()); } }
private IndexDependencyModel createIndexDependencyModel(Set<Impact> changes) { Set<String> entityTypeIds = changes.stream().map(Impact::getEntityTypeId).collect(toSet()); boolean hasReferences = dataService.query(ATTRIBUTE_META_DATA).in(REF_ENTITY_TYPE, entityTypeIds).count() > 0; if (hasReferences) { return new IndexDependencyModel(getEntityTypes()); } else { return new IndexDependencyModel(emptyList()); } }
@Override public Iterable<String> getEntityTypeIds() { return dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(BACKEND, POSTGRESQL) .fetch(getEntityTypeFetch()) .findAll() .map(EntityType::getId) ::iterator; }
@Override @Nullable public Questionnaire findQuestionnaireEntity(String entityTypeId) { Entity questionnaireInstance = dataService.query(entityTypeId).eq(OWNER_USERNAME, getCurrentUsername()).findOne(); if (questionnaireInstance != null) { return questionnaireFactory.create(questionnaireInstance); } else { return null; } } }
private Stream<App> getApps() { Query<App> query = dataService.query(APP, App.class); query.sort().on(AppMetaData.NAME); Stream<App> apps = query.findAll(); if (!permissionService.hasPermissionOnEntityType(APP, Permission.WRITE)) { apps = apps.filter(App::isActive); } return apps; }
/** * Retrieves an ontology with a specific IRI. * * @param iri the IRI of the ontology */ public Ontology getOntology(String iri) { org.molgenis.ontology.core.meta.Ontology ontology = dataService .query(ONTOLOGY, org.molgenis.ontology.core.meta.Ontology.class) .eq(ONTOLOGY_IRI, iri) .findOne(); return toOntology(ontology); }
@Override public AppResponse getAppByName(String appName) { App app = dataService.query(AppMetadata.APP, App.class).eq(AppMetadata.NAME, appName).findOne(); if (app == null) { throw new AppForURIDoesNotExistException(appName); } return AppResponse.create(app); }
@Override public Iterator<Repository<Entity>> iterator() { return dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(BACKEND, POSTGRESQL) .and() .eq(IS_ABSTRACT, false) .fetch(getEntityTypeFetch()) .findAll() .map(this::getRepository) .iterator(); }
private void bootstrap(SystemEntityType systemEntityType) { dataService .query(systemEntityType.getId()) .eq(STATUS, RUNNING) .or() .eq(STATUS, PENDING) .findAll() .forEach(this::setFailed); }
private Token getMolgenisToken(String token) { Token molgenisToken = dataService.query(TOKEN, Token.class).eq(TOKEN_ATTR, token).findOne(); if (molgenisToken == null || molgenisToken.isExpired()) { throw new UnknownTokenException("Invalid token"); } return molgenisToken; } }
private void deleteOldRecoveryCodes(String userId) { runAsSystem( () -> { Stream<RecoveryCode> recoveryCodes = dataService.query(RECOVERY_CODE, RecoveryCode.class).eq(USER_ID, userId).findAll(); dataService.delete(RECOVERY_CODE, recoveryCodes); }); }
private Optional<User> getUser(OidcUser oidcUser, OidcUserRequest userRequest) { OidcUserMapping oidcUserMapping = dataService .query(OIDC_USER_MAPPING, OidcUserMapping.class) .eq(OIDC_CLIENT, userRequest.getClientRegistration().getRegistrationId()) .and() .eq(OIDC_USERNAME, oidcUser.getSubject()) .findOne(); return oidcUserMapping != null ? Optional.of(oidcUserMapping.getUser()) : Optional.empty(); }
@Override @RunAsSystem public UserDetails loadUserByUsername(String username) { User user = dataService .query(UserMetaData.USER, User.class) .eq(UserMetaData.USERNAME, username) .findOne(); if (user == null) { throw new UsernameNotFoundException("unknown user '" + username + "'"); } Collection<? extends GrantedAuthority> authorities = getAuthorities(user); return new org.springframework.security.core.userdetails.User( user.getUsername(), user.getPassword(), user.isActive(), true, true, true, authorities); }
@Override public Stream<RecoveryCode> getRecoveryCodes() { String userId = getUser().getId(); return runAsSystem( () -> dataService.query(RECOVERY_CODE, RecoveryCode.class).eq(USER_ID, userId).findAll()); }
@Override public Stream<EntityType> getQuestionnaires() { return dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(EntityTypeMetadata.EXTENDS, QUESTIONNAIRE) .findAll() .filter( entityType -> userPermissionEvaluator.hasPermission( new EntityTypeIdentity(entityType.getId()), EntityTypePermission.ADD_DATA)) .filter( entityType -> userPermissionEvaluator.hasPermission( new EntityTypeIdentity(entityType.getId()), EntityTypePermission.UPDATE_DATA)); }
@Override @RunAsSystem public void changePassword(String username, String newPassword) { User user = dataService.query(USER, User.class).eq(USERNAME, username).findOne(); if (user == null) { throw new MolgenisUserException(format("Unknown user [%s]", username)); } if (!user.isActive()) { throw new DisabledException(MolgenisLoginController.ERROR_MESSAGE_DISABLED); } user.setPassword(newPassword); user.setChangePassword(false); dataService.update(USER, user); LOG.info("Changed password of user [{}]", username); }
private UserSecret getSecret() { User user = getUser(); UserSecret secret = runAsSystem( () -> dataService .query(USER_SECRET, UserSecret.class) .eq(UserSecretMetaData.USER_ID, user.getId()) .findOne()); if (secret != null) { return secret; } else { throw new InternalAuthenticationServiceException( format( "Secret not found, user: [{0}] is not configured for two factor authentication", user.getUsername())); } }
@Override public void resetSecretForUser() { User user = getUser(); Stream<UserSecret> userSecrets = runAsSystem( () -> dataService .query(USER_SECRET, UserSecret.class) .eq(USER_ID, user.getId()) .findAll()); //noinspection RedundantCast runAsSystem((Runnable) () -> dataService.delete(USER_SECRET, userSecrets)); }
@Override public Repository<Entity> getRepository(String id) { EntityType entityType = dataService .query(ENTITY_TYPE_META_DATA, EntityType.class) .eq(BACKEND, POSTGRESQL) .and() .eq(ID, id) .and() .eq(IS_ABSTRACT, false) .fetch(getEntityTypeFetch()) .findOne(); return getRepository(entityType); }