public <B> Promise<B> map(Function<? super T, ? extends B> function) { return delegate.map(function); }
@Override public Promise<HipChatToken> get() { return delegate.get().map(new Function<String, HipChatToken>() { @Override public HipChatToken apply(String input) { return new SimpleHipChatToken(input); } }); } }
@Override public <B> Promise<B> map(Function<? super A, ? extends B> function) { return delegate().map(function); }
@Override public Promise<Result<List<CollapsedRoom>>> getAllPublicRooms() { return client.list().map(new Function<Result<List<Room>>, Result<List<CollapsedRoom>>>() { @Override public Result<List<CollapsedRoom>> apply(Result<List<Room>> input) { if (input.isSuccess()) { final Iterable<CollapsedRoom> publicRooms = Iterables.transform( Iterables.filter(input.success(), isPublicRoom()), convertToCollapsedRoom() ); return Result.<List<CollapsedRoom>>success(ImmutableList.copyOf(publicRooms)); } else { return input.asError(); } } }); }
@Nonnull @Override public Promise<Attachment> copy(@Nonnull final Attachment originalAttachment, @Nonnull final Attachment metaData, @Nonnull final String newIssueKey) { return getBackwardCompatibleStoreAdapter() .copyAttachment(AttachmentKeys.from(originalAttachment), AttachmentKeys.from(metaData)).map(new com.google.common.base.Function<Unit, Attachment>() { @Override public Attachment apply(@Nullable final Unit unit) { return metaData; } }); }
@Override public Promise<Void> deleteAttachmentContainerForIssue(@Nonnull final Issue issue) { return getBackwardCompatibleStoreAdapter().deleteAttachmentContainerForIssue(issue).map(unitToVoid()); }
@Override public Promise<Result<List<Room>>> list() { return toGetAsyncJsonResource(client) .apply(buildUrl("rooms/list")) .map(responseMapper.to(RoomsResponse.class)) .recover(ResourceMapper.<RoomsResponse>handleError()) .map(new Function<Result<RoomsResponse>, Result<List<Room>>>() { @Override public Result<List<Room>> apply(Result<RoomsResponse> result) { if (result.isSuccess()) { return Result.success(result.success().rooms); } else { return result.asError(); } } }); }
@Override public Promise<Void> deleteAttachment(@Nonnull final Attachment attachment) { final AttachmentKey attachmentKey = attachmentKeyMapper.fromAttachment(attachment); return getBackwardCompatibleStoreAdapter().deleteAttachment(attachmentKey).map(unitToVoid()); }
@Override public Promise<Attachment> putAttachment(final Attachment metadata, final InputStream source) { final StoreAttachmentBean storeAttachmentBean = storeAttachmentBeanMapper.mapToBean(metadata, source); return putAttachment(storeAttachmentBean).map(Functions.constant(metadata)); }
@Nonnull @Override public Promise<TemporaryAttachmentId> putTemporaryAttachment(final InputStream inputStream, final long size) { final String tempId = uniqueIdentifierGenerator.getNextId(); final TemporaryAttachmentId temporaryAttachmentId = TemporaryAttachmentId.fromString(tempId); return putBlobToStore(inputStream, tempId, size).map(Functions.constant(temporaryAttachmentId)); }
private Promise<Map<String, Result<ExpandedRoom>>> expandRoomsForIds(final HipChatAPI hipChatAPI, final Iterable<String> roomIds, final ImmutableMap.Builder<String, Result<ExpandedRoom>> results) { final ImmutableList.Builder<Promise<RoomResult>> builder = ImmutableList .builder(); final boolean usingPersonalToken = hipChatAPI.getTokenType() instanceof HipChatAPI.TokenType.PersonalToken; //Only schedule at most BATCH_SIZE requests for (final String roomId : Iterables.take(BATCH_SIZE, roomIds)) { Promise<Result<ExpandedRoom>> roomPromise = hipChatAPI.rooms() .getRoom(roomId); if (!usingPersonalToken) { roomPromise = roomPromise.map(FILTER_PRIVATE_ROOM); } builder.add(roomPromise.map(toRoomResult(roomId))); } return Promises.when(builder.build()).flatMap(expandRoomBatch(hipChatAPI, roomIds, results)); }
@Override public Promise<Result<Void>> message(String roomIdOrName, String from, String message, Option<Message.Format> format, Option<Message.BackgroundColor> color, Option<Boolean> notify) { final Form params = messageParametersAsMap(roomIdOrName, from, message, format, color, notify); return toPostAsyncFormResource(client, params) .apply(buildUrl("rooms/message")) .map(responseMapper.toVoid()) .recover(ResourceMapper.<Void>handleError()); }
public Promise<Result<Void>> canAuthenticate(Option<String> token) { if (token.isEmpty()) { return Promises.promise(Result.<Void>error("Token does not exist")); } return ResourceMapper.toGetAsyncJsonResource(client) .apply(URI.create(configurationManager.getApiBaseUrl() + "v1/?auth_token=" + token.get())) .map(responseMapper.toVoid()) .recover(ResourceMapper.<Void>handleError()); }
@Override public Promise<StoreAttachmentResult> putAttachment(final StoreAttachmentBean storeAttachmentBean) { //noinspection NullableProblems return primaryAttachmentStore.putTemporaryAttachment(storeAttachmentBean.getStream(), storeAttachmentBean.getSize()) .flatMap(new com.google.common.base.Function<TemporaryAttachmentId, Promise<Unit>>() { @Override public Promise<Unit> apply(final TemporaryAttachmentId temporaryAttachmentId) { return moveTemporaryToAttachment(temporaryAttachmentId, storeAttachmentBean.getAttachmentKey()); } }) .map(Functions.constant(StoreAttachmentResult.created())); }
@Override public Promise<Result<User.Group>> getCurrentGroup(final UserService userService) { final Promise<Result<AllUsersResult>> usersPromise = userService.getAllUsers() .startIndex(0) .maxResults(1) .includeDeleted(false) .includeGuests(false) .expand("items") .build(); try { return usersPromise.map(new Function<Result<AllUsersResult>, Result<User.Group>>() { @Override public Result<User.Group> apply(@Nonnull Result<AllUsersResult> inputResult) { if (inputResult.isError()) { logger.warn("Error result returned when fetching list of users."); return inputResult.asError(); } final List<CollapsedUser> users = inputResult.success().getUsers(); if (isEmpty(users)) { return Result.error("Empty list of users returned."); } final ExpandedUser user = users.get(0).expanded(); return Result.success(user.getGroup()); } }); } catch (Exception e) { logger.error("Encountered error while waiting for list of users.", e); return errorResultPromise(e); } }
@Override public Promise<Void> move(final Attachment metaData, final String newIssueKey) { final AttachmentKey oldAttachmentKey = attachmentKeyMapper.fromAttachment(metaData); final IssueKey ik = IssueKey.from(newIssueKey); final Project project = projectManager.getProjectObjByKey(ik.getProjectKey()); final String originalProjectKey = project.getOriginalKey(); final AttachmentKey newAttachmentKey = AttachmentKeys.from( originalProjectKey, newIssueKey, oldAttachmentKey.getAttachmentFilename(), oldAttachmentKey.getAttachmentId()); return moveAttachment(oldAttachmentKey, newAttachmentKey).map(unitToVoid()); }
.users() .getUser(emailAddress) .map(new Function<Result<User>, Result<Boolean>>() { @Override public Result<Boolean> apply(Result<User> userResult) {
.users() .getUser(emailAddress) .map(new Function<Result<User>, Result<Boolean>>() { @Override public Result<Boolean> apply(Result<User> userResult) {