Java Code Examples for reactor.core.publisher.Mono#justOrEmpty()

private Mono<?> prepareAttributeMono(String attributeName, ResolvableType attributeType,
		BindingContext context, ServerWebExchange exchange) {

	Object attribute = context.getModel().asMap().get(attributeName);

	if (attribute == null) {
		attribute = findAndRemoveReactiveAttribute(context.getModel(), attributeName);
	}

	if (attribute == null) {
		return createAttribute(attributeName, attributeType.toClass(), context, exchange);
	}

	ReactiveAdapter adapterFrom = getAdapterRegistry().getAdapter(null, attribute);
	if (adapterFrom != null) {
		Assert.isTrue(!adapterFrom.isMultiValue(), "Data binding only supports single-value async types");
		return Mono.from(adapterFrom.toPublisher(attribute));
	}
	else {
		return Mono.justOrEmpty(attribute);
	}
}
 

@Override
public Mono<MailboxSession> createMailboxSession(HttpServerRequest httpRequest) throws MailboxSessionCreationException {
    Stream<Username> userLoginStream = extractTokensFromAuthHeaders(authHeaders(httpRequest))
        .filter(tokenManager::verify)
        .map(tokenManager::extractLogin)
        .map(Username::of)
        .peek(username -> {
            try {
                usersRepository.assertValid(username);
            } catch (UsersRepositoryException e) {
                throw new MailboxSessionCreationException(e);
            }
        });

    Stream<MailboxSession> mailboxSessionStream = userLoginStream
            .map(mailboxManager::createSystemSession);

    return Mono.justOrEmpty(mailboxSessionStream.findFirst());
}
 

@Override
public <T> Mono<T> toMono(@Nullable Object source) {
    if (source instanceof Mono) {
        return (Mono) source;
    } else if (source instanceof Publisher) {
        return Mono.from((Publisher) source);
    } else {
        return (Mono<T>) Mono.justOrEmpty(source);
    }
}
 

public Mono<ServerResponse> countLogins(ServerRequest req) {
	
	Mono<Long> count = Flux.fromIterable(logindetailsServiceImpl.findAllLogindetails())
			.count();
	TotalUsers countEmp = new TotalUsers();
	countEmp.setCount(count.block());
	Mono<TotalUsers> monoCntLogins = Mono.justOrEmpty(countEmp);
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(monoCntLogins, TotalUsers.class)
			.switchIfEmpty(ServerResponse.notFound().build());
}
 

public Mono<ServerResponse> countDepts(ServerRequest req) {
	Mono<Long> count = Flux.fromIterable(departmentServiceImpl.findAllDepts())
			.count();	
	CountDept countDept = new CountDept();
	countDept.setCount(count.block());
	Mono<CountDept> monoCntDept = Mono.justOrEmpty(countDept);
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(monoCntDept, CountDept.class)
			.switchIfEmpty(ServerResponse.notFound().build());
}
 

public Mono<String> customer(Authentication authentication) {
    return Mono.justOrEmpty(authentication
      .getPrincipal()
      .toString()
      .startsWith("customer") ? authentication
      .getPrincipal()
      .toString() : null);
}
 

@Override
public Mono<Void> delete(DeleteJobRequest request) {
	for (int i = 0; i < this.jobResources.size(); i++) {
		if (this.jobResources.get(i).getId().equals(request.getJobId())) {
			jobResources.remove(i);
			break;
		}
	}
	return Mono.justOrEmpty(null);
}
 

@Override
public Mono<Void> removeRelations(ReactiveProject source, Collection<Long> targetIds, ResourceField field) {
	ArrayList<Long> ids = new ArrayList<>();
	if (relationMap.containsKey(source.getId())) {
		ids.addAll(relationMap.getList(source.getId()));
	}
	ids.removeAll(targetIds);
	relationMap.set(source.getId(), ids);
	return Mono.justOrEmpty(null);
}
 

public Mono<ServerResponse> countEmps(ServerRequest req) {
	
	Mono<Long> count = Flux.fromIterable(employeeServiceImpl.findAllEmps())
			.count();
	CountEmp countEmp = new CountEmp();
	countEmp.setCount(count.block());
	Mono<CountEmp> monoCntEmp = Mono.justOrEmpty(countEmp);
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(monoCntEmp, CountEmp.class)
			.switchIfEmpty(ServerResponse.notFound().build());
}
 

@Override
public Mono<ServiceDefinition> getServiceDefinition(final String serviceId) {
	return Mono.justOrEmpty(serviceDefs.get(serviceId));
}
 

@Override
public Mono<Void> setRelation(ReactiveTask source, Long targetId, ResourceField field) {
	relationMap.put(source.getId(), targetId);
	return Mono.justOrEmpty(null);
}
 

@Override
protected final Mono<Object> resolveName(String name, MethodParameter param, ServerWebExchange exchange) {
	return Mono.justOrEmpty(resolveNamedValue(name, param, exchange));
}
 

@Override
public Mono<User> getUser(Integer id){
	return Mono.justOrEmpty(this.users.get(id));		
}
 

@Override
protected final Mono<Object> resolveName(String name, MethodParameter param, ServerWebExchange exchange) {
	return Mono.justOrEmpty(resolveNamedValue(name, param, exchange));
}
 

public Mono<Movie> getById(final String id) {
    return Mono.justOrEmpty(repository.findById(id));
//    return repository.findById(id);
  }
 

@Override
public Mono<String> getName() {
	return Mono.justOrEmpty(name);
}
 

@Override
public Mono<WebSession> session() {
	return Mono.justOrEmpty(this.session);
}
 

public Mono<TopicPart> get(String topic) {
    return Mono.justOrEmpty(getOrDefault(topic, ((topicPart, s) -> null)));
}
 

/**
 * 获取单个用户
 *
 * @param id
 * @return
 */
@GetMapping("/{id}")
public Mono<User> getUser(@PathVariable Long id) {
    return Mono.justOrEmpty(users.get(id));
}
 

/**
 * {@inheritDoc}
 * <p>By default this simply delegates to {@link #resolveArgumentValue} for
 * synchronous resolution.
 */
@Override
default Mono<Object> resolveArgument(MethodParameter parameter, Message<?> message) {
	return Mono.justOrEmpty(resolveArgumentValue(parameter, message));
}