@Override public Single<Boolean> apply(Maybe<Object> f) throws Exception { return f.isEmpty(); } });
@Override public SingleSource<Boolean> apply(Maybe<Object> m) throws Exception { return m.isEmpty(); } });
@Override public Maybe<Boolean> apply(Maybe<Object> m) throws Exception { return m.isEmpty().toMaybe(); } });
@Override public Maybe<Boolean> apply(Maybe<Object> f) throws Exception { return f.isEmpty().toMaybe(); } });
@Test public void normal() { Maybe.just(1) .isEmpty() .test() .assertResult(false); }
@Test public void source() { Maybe<Integer> m = Maybe.just(1); assertSame(m, (((HasUpstreamMaybeSource<?>)m.isEmpty()).source())); } }
@Test public void isDisposed() { PublishProcessor<Integer> pp = PublishProcessor.create(); TestHelper.checkDisposed(pp.singleElement().isEmpty()); }
@Test public void empty() { Maybe.empty() .isEmpty() .test() .assertResult(true); }
@Test public void fusedBackToMaybe() { assertTrue(Maybe.just(1) .isEmpty() .toMaybe() instanceof MaybeIsEmpty); }
@Test public void error() { Maybe.error(new TestException()) .isEmpty() .test() .assertFailure(TestException.class); }
@Test public void isDisposedToMaybe() { PublishProcessor<Integer> pp = PublishProcessor.create(); TestHelper.checkDisposed(pp.singleElement().isEmpty().toMaybe()); }
@Test public void normalToMaybe() { Maybe.just(1) .isEmpty() .toMaybe() .test() .assertResult(false); }
@Test public void emptyToMaybe() { Maybe.empty() .isEmpty() .toMaybe() .test() .assertResult(true); }
@Test public void errorToMaybe() { Maybe.error(new TestException()) .isEmpty() .toMaybe() .test() .assertFailure(TestException.class); }
private Single<Boolean> checkFormUniqueness(String domain, String formTemplate) { return findByDomainAndTemplate(domain, formTemplate) .isEmpty() .map(isEmpty -> { if (!isEmpty) { throw new FormAlreadyExistsException(formTemplate); } return true; }); } }
private Single<IdentityProvider> updateDefaultIdp(Domain domain) { return identityProviderService.findById(DEFAULT_IDP_PREFIX + domain.getId()) .isEmpty() .flatMap(isEmpty -> { if (isEmpty) { logger.info("No default idp found for domain {}, update domain", domain.getName()); return identityProviderManager.create(domain.getId()); } return Single.just(new IdentityProvider()); }); }
@Override public Single<Scope> create(String domain, NewScope newScope) { LOGGER.debug("Create a new scope {} for domain {}", newScope, domain); String scopeKey = newScope.getKey().toLowerCase(); return scopeRepository.findByDomainAndKey(domain, scopeKey) .isEmpty() .flatMap(empty -> { if (!empty) { throw new ScopeAlreadyExistsException(scopeKey, domain); } Scope scope = new Scope(); scope.setId(UUID.toString(UUID.random())); scope.setDomain(domain); scope.setKey(scopeKey); scope.setName(newScope.getName()); scope.setDescription(newScope.getDescription()); scope.setCreatedAt(new Date()); scope.setUpdatedAt(new Date()); return scopeRepository.create(scope); }) .onErrorResumeNext(ex -> { if (ex instanceof AbstractManagementException) { return Single.error(ex); } LOGGER.error("An error occurs while trying to create a scope", ex); return Single.error(new TechnicalManagementException("An error occurs while trying to create a scope", ex)); }); }
@Override public Single<ScopeApproval> upsert(ScopeApproval scopeApproval) { return Observable.fromPublisher(scopeApprovalsCollection.find( and(eq(FIELD_DOMAIN, scopeApproval.getDomain()), eq(FIELD_CLIENT_ID, scopeApproval.getClientId()), eq(FIELD_USER_ID, scopeApproval.getUserId()), eq(FIELD_SCOPE, scopeApproval.getScope()))).first()) .firstElement() .isEmpty() .flatMap(isEmpty -> { if (isEmpty) { return create(scopeApproval); } else { scopeApproval.setUpdatedAt(new Date()); return update(scopeApproval); } }); }
@Override public Single<Client> create(String domain, NewClient newClient) { LOGGER.debug("Create a new client {} for domain {}", newClient, domain); return clientRepository.findByClientIdAndDomain(newClient.getClientId(), domain) .isEmpty() .flatMap(isEmpty -> { if (!isEmpty) { return Single.error(new ClientAlreadyExistsException(newClient.getClientId(), domain)); } Client client = new Client(); client.setClientId(newClient.getClientId()); client.setClientSecret(newClient.getClientSecret()); client.setClientName(newClient.getClientName()); client.setDomain(domain); return Single.just(client); }) .flatMap(client -> this.create(client)) .onErrorResumeNext(this::handleError); }
@Override public Single<User> create(User user) { return findByUsername(user.getUsername()) .isEmpty() .flatMap(isEmpty -> { if (!isEmpty) { return Single.error(new UserAlreadyExistsException(user.getUsername())); } else { Document document = new Document(); // set technical id document.put(FIELD_ID, user.getId() != null ? user.getId() : UUID.toString(UUID.random())); // set username document.put(configuration.getUsernameField(), user.getUsername()); // set password if (user.getCredentials() != null) { document.put(configuration.getPasswordField(), passwordEncoder.encode(user.getCredentials())); } // set additional information if (user.getAdditionalInformation() != null) { document.putAll(user.getAdditionalInformation()); } // set date fields document.put(FIELD_CREATED_AT, new Date()); document.put(FIELD_UPDATED_AT, document.get(FIELD_CREATED_AT)); return Single.fromPublisher(usersCollection.insertOne(document)).flatMap(success -> findById(document.getString(FIELD_ID)).toSingle()); } }); }