@Test public void testSendBinaryDataWithContentType() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false", "--spring.cloud.stream.bindings.output.contentType=image/jpeg")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); byte[] data = new byte[] { 0, 1, 2, 3 }; source.output().send(MessageBuilder.withPayload(data) .build()); Message<byte[]> message = (Message<byte[]>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.IMAGE_JPEG)); assertThat(message.getPayload()).isEqualTo(data); } }
@ApiOperation(value = "update a conversation", response = Conversation.class) @RequestMapping(value = "{id}", method = RequestMethod.PUT, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<?> updateConversation( AuthContext authContext, @PathVariable("id") ObjectId id, @RequestBody Conversation conversation ) { final Conversation storedC = authenticationService.assertConversation(authContext, id); // make sure the id is the right one conversation.setId(storedC.getId()); final Client client = authenticationService.assertClient(authContext, conversation.getOwner()); //TODO: check that the // * the user is from the client the stored conversation as as owner return ResponseEntity.ok(conversationService.update(client, conversation,true, null)); }
@ApiOperation(value = "signup", notes = "create a new account", response = UserDetailsResponse.class) @RequestMapping(value = "/auth/signup", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<UserDetailsResponse> signUp(@RequestBody Map<String, String> data) { if (!securityConfigurationProperties.getMongo().isEnableSignup()) { return ResponseEntity.badRequest().build(); } // Public access final String login = data.get("login"), password = data.get("password"), mail = data.get("email"); if ( StringUtils.isNoneBlank(login, password, mail) && emailValidator.isValid(mail)) { return ResponseEntity.ok(UserDetailsResponse.wrap(accountService.createAccount(login, mail, password))); } else { return ResponseEntity.badRequest().build(); } }
@Test public void handleErrorFrameWithConversionException() throws Exception { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); accessor.setContentType(MimeTypeUtils.APPLICATION_JSON); accessor.addNativeHeader("foo", "bar"); accessor.setLeaveMutable(true); byte[] payload = "{'foo':'bar'}".getBytes(UTF_8); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(this.sessionHandler.getPayloadType(stompHeaders)).thenReturn(Map.class); this.session.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); verify(this.sessionHandler).getPayloadType(stompHeaders); verify(this.sessionHandler).handleException(same(this.session), same(StompCommand.ERROR), eq(stompHeaders), same(payload), any(MessageConversionException.class)); verifyNoMoreInteractions(this.sessionHandler); }
@Test public void handleMessageFrame() throws Exception { this.session.afterConnected(this.connection); StompFrameHandler frameHandler = mock(StompFrameHandler.class); String destination = "/topic/foo"; Subscription subscription = this.session.subscribe(destination, frameHandler); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE); accessor.setDestination(destination); accessor.setSubscriptionId(subscription.getSubscriptionId()); accessor.setContentType(MimeTypeUtils.TEXT_PLAIN); accessor.setMessageId("1"); accessor.setLeaveMutable(true); String payload = "sample payload"; StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(frameHandler.getPayloadType(stompHeaders)).thenReturn(String.class); this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(UTF_8), accessor.getMessageHeaders())); verify(frameHandler).getPayloadType(stompHeaders); verify(frameHandler).handleFrame(stompHeaders, payload); verifyNoMoreInteractions(frameHandler); }
@Test public void toNativeHeadersMessageFrame() { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.MESSAGE); headers.setSubscriptionId("s1"); headers.setDestination("/d"); headers.setContentType(MimeTypeUtils.APPLICATION_JSON); headers.updateStompCommandAsServerMessage(); Map<String, List<String>> actual = headers.toNativeHeaderMap(); assertEquals(actual.toString(), 4, actual.size()); assertEquals("s1", actual.get(StompHeaderAccessor.STOMP_SUBSCRIPTION_HEADER).get(0)); assertEquals("/d", actual.get(StompHeaderAccessor.STOMP_DESTINATION_HEADER).get(0)); assertEquals("application/json", actual.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)); assertNotNull("message-id was not created", actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0)); }
@Test public void getShortLogMessage() { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SEND); accessor.setDestination("/foo"); accessor.setContentType(MimeTypeUtils.APPLICATION_JSON); accessor.setSessionId("123"); String actual = accessor.getShortLogMessage("payload".getBytes(Charset.forName("UTF-8"))); assertEquals("SEND /foo session=123 application/json payload=payload", actual); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 80; i++) { sb.append("a"); } final String payload = sb.toString() + " > 80"; actual = accessor.getShortLogMessage(payload.getBytes(UTF_8)); assertEquals("SEND /foo session=123 application/json payload=" + sb + "...(truncated)", actual); }
@Test public void sendWebSocketBinary() throws Exception { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SEND); accessor.setDestination("/b"); accessor.setContentType(MimeTypeUtils.APPLICATION_OCTET_STREAM); byte[] payload = "payload".getBytes(UTF_8); getTcpConnection().send(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); ArgumentCaptor<BinaryMessage> binaryMessageCaptor = ArgumentCaptor.forClass(BinaryMessage.class); verify(this.webSocketSession).sendMessage(binaryMessageCaptor.capture()); BinaryMessage binaryMessage = binaryMessageCaptor.getValue(); assertNotNull(binaryMessage); assertEquals("SEND\ndestination:/b\ncontent-type:application/octet-stream\ncontent-length:7\n\npayload\0", new String(binaryMessage.getPayload().array(), UTF_8)); }
@Override public Response serve(IHTTPSession session) { Method m = session.getMethod(); switch(m) { case GET: return doGet(session); case POST: return doPost(session); default: return newFixedLengthResponse(Status.NOT_IMPLEMENTED, MimeTypeUtils.TEXT_PLAIN_VALUE,"HTTP "+m); } }
public void read(String mimeType, InputStream is) throws IOException { Assert.hasText(mimeType, "MimeType string is null or empty."); Assert.notNull(is, "InputStream is null or empty."); MimeType mimeTypeObj = MimeTypeUtils.parseMimeType(mimeType); if(MimeTypeUtils.APPLICATION_JSON.equals(mimeTypeObj)) { Assert.hasText(mimeType, "MimeType '" + mimeType + "' is not supported."); } AppConfigObject aco = objectMapper.readValue(is, AppConfigObject.class); final String version = aco.getVersion(); if(!VERSION.equals(version)) { throw new RuntimeException("Unsupported version of config: " + version); } ConfigReadContext ctx = new ConfigReadContext(); Map<String, Object> map = aco.getData(); Assert.notNull(map, "config has empty map"); for(Map.Entry<String, Object> oe : map.entrySet()) { String name = oe.getKey(); ReConfigurableAdapter ca = adapters.get(name); Assert.notNull(ca, "Can not find adapter with name: " + name); Object value = oe.getValue(); Assert.notNull(value, "Config object is null for name: " + name); ca.setConfig(ctx, value); } }
@RequestMapping(path = "config", method = RequestMethod.GET) public ResponseEntity<StreamingResponseBody> getConfig() { HttpHeaders headers = new HttpHeaders(); // 'produces' in annotation does not work with stream headers.setContentType(MediaType.APPLICATION_JSON); headers.set(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"cluman_config.json\""); return new ResponseEntity<>((os) -> { appConfigService.write(MimeTypeUtils.APPLICATION_JSON_VALUE, os); }, headers, HttpStatus.OK); }
/** * Uploads a byte array using FileResource and ExternalFileResource * * @param name name of the file to be stored * @param bytes the byte array representing the file to be stored * @return url pointing to the uploaded resource * @throws IOException */ private String uploadImage( String name, byte[] bytes ) throws IOException { FileResource fileResource = new FileResource( name, MimeTypeUtils.IMAGE_PNG.toString(), // All files uploaded from PushAnalysis is PNG. bytes.length, ByteSource.wrap( bytes ).hash( Hashing.md5() ).toString(), FileResourceDomain.PUSH_ANALYSIS ); fileResourceService.saveFileResource( fileResource, bytes ); ExternalFileResource externalFileResource = new ExternalFileResource(); externalFileResource.setFileResource( fileResource ); externalFileResource.setExpires( null ); String accessToken = externalFileResourceService.saveExternalFileResource( externalFileResource ); return systemSettingManager.getInstanceBaseUrl() + "/api/externalFileResources/" + accessToken; }
@RequestMapping(value = "/{kudosId}/plusOnes", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE, produces = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseMessage addNewPlusOne(@RequestBody @Valid NewPlusOneRequest newPlusOneRequest, BindingResult result, @PathVariable("kudosId") Long kudosId) { logger.info("New request " + newPlusOneRequest.toString()); if (result.hasErrors()) { throw new IllegalArgumentException("Invalid request data " + result.toString()); } Kudos kudos = kudosRepository.findOne(kudosId); if(kudos == null) { throw new IllegalArgumentException("There is no kudos with id=" + kudosId); } PlusOne plusOne = new PlusOne( slackUsersProvider.mapSlackUserNameToUserId(newPlusOneRequest.getUserName()), newPlusOneRequest.getDescription(), kudos ); plusOneRepository.save(plusOne); kudos.addPlusOne(plusOne); return new ResponseMessage("ok"); }
@Test public void testOneRequiredGroup() throws Exception { B binder = getBinder(); PP producerProperties = createProducerProperties(); DirectChannel output = createBindableChannel("output", createProducerBindingProperties(producerProperties)); String testDestination = "testDestination" + UUID.randomUUID().toString().replace("-", ""); producerProperties.setRequiredGroups("test1"); Binding<MessageChannel> producerBinding = binder.bindProducer(testDestination, output, producerProperties); String testPayload = "foo-" + UUID.randomUUID().toString(); output.send(MessageBuilder.withPayload(testPayload).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build()); QueueChannel inbound1 = new QueueChannel(); Binding<MessageChannel> consumerBinding = binder.bindConsumer(testDestination, "test1", inbound1, createConsumerProperties()); Message<?> receivedMessage1 = receive(inbound1); assertThat(receivedMessage1).isNotNull(); assertThat(new String((byte[]) receivedMessage1.getPayload())).isEqualTo(testPayload); producerBinding.unbind(); consumerBinding.unbind(); }
@Test public void testSendWithDefaultContentType() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); User user = new User("Alice"); source.output().send(MessageBuilder.withPayload(user).build()); Message<String> message = (Message<String>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); User received = mapper.readValue(message.getPayload(), User.class); assertThat( message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_JSON)); assertThat(user.getName()).isEqualTo(received.getName()); } }
@Test public void testSendJsonAsString() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); User user = new User("Alice"); String json = mapper.writeValueAsString(user); source.output().send(MessageBuilder.withPayload(user).build()); Message<String> message = (Message<String>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat( message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_JSON)); assertThat(json).isEqualTo(message.getPayload()); } }
@Test public void testSendJsonString() throws Exception{ try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); source.output().send(MessageBuilder.withPayload("foo").build()); Message<String> message = (Message<String>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat( message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_JSON)); assertThat("foo").isEqualTo(message.getPayload()); } }
@Test public void testSendBynaryData() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); byte[] data = new byte[] { 0, 1, 2, 3 }; source.output().send(MessageBuilder.withPayload(data).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_OCTET_STREAM).build()); Message<byte[]> message = (Message<byte[]>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat( message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_OCTET_STREAM)); assertThat(message.getPayload()).isEqualTo(data); } }
@Test public void testSendBinaryDataWithContentTypeUsingHeaders() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); byte[] data = new byte[] { 0, 1, 2, 3 }; source.output().send(MessageBuilder.withPayload(data) .setHeader(MessageHeaders.CONTENT_TYPE,MimeTypeUtils.IMAGE_JPEG) .build()); Message<byte[]> message = (Message<byte[]>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.IMAGE_JPEG)); assertThat(message.getPayload()).isEqualTo(data); } }
@Test public void testSendStringType() throws Exception{ try (ConfigurableApplicationContext context = SpringApplication.run( SourceApplication.class, "--server.port=0", "--spring.jmx.enabled=false", "--spring.cloud.stream.bindings.output.contentType=text/plain")) { MessageCollector collector = context.getBean(MessageCollector.class); Source source = context.getBean(Source.class); User user = new User("Alice"); source.output().send(MessageBuilder.withPayload(user).build()); Message<String> message = (Message<String>) collector .forChannel(source.output()).poll(1, TimeUnit.SECONDS); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.TEXT_PLAIN)); assertThat(message.getPayload()).isEqualTo(user.toString()); } }
@Test public void testReceiveWithDefaults() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SinkApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { TestSink testSink = context.getBean(TestSink.class); SinkApplication sourceApp = context.getBean(SinkApplication.class); User user = new User("Alice"); testSink.pojo().send(MessageBuilder.withPayload(mapper.writeValueAsBytes(user)).build()); Map<String,Object> headers = (Map<String, Object>) sourceApp.arguments.pop(); User received = (User)sourceApp.arguments.pop(); assertThat(((MimeType)headers.get(MessageHeaders.CONTENT_TYPE)) .includes(MimeTypeUtils.APPLICATION_JSON)); assertThat(user.getName()).isEqualTo(received.getName()); } }
@Test public void testReceiveRawWithDifferentContentTypes() throws Exception { try (ConfigurableApplicationContext context = SpringApplication.run( SinkApplication.class, "--server.port=0", "--spring.jmx.enabled=false")) { TestSink testSink = context.getBean(TestSink.class); SinkApplication sourceApp = context.getBean(SinkApplication.class); testSink.raw().send(MessageBuilder.withPayload(new byte[4]) .setHeader(MessageHeaders.CONTENT_TYPE,MimeTypeUtils.IMAGE_JPEG) .build()); testSink.raw().send(MessageBuilder.withPayload(new byte[4]) .setHeader(MessageHeaders.CONTENT_TYPE,MimeTypeUtils.IMAGE_GIF) .build()); Map<String,Object> headers = (Map<String, Object>) sourceApp.arguments.pop(); sourceApp.arguments.pop(); assertThat(((MimeType)headers.get(MessageHeaders.CONTENT_TYPE)) .includes(MimeTypeUtils.IMAGE_GIF)); headers = (Map<String, Object>) sourceApp.arguments.pop(); sourceApp.arguments.pop(); assertThat(((MimeType)headers.get(MessageHeaders.CONTENT_TYPE)) .includes(MimeTypeUtils.IMAGE_JPEG)); } }
@Test @SuppressWarnings("unchecked") public void testHandlerBean() throws Exception { ConfigurableApplicationContext context = SpringApplication.run(this.configClass, "--spring.cloud.stream.bindings.output.contentType=application/json", "--server.port=0"); MessageCollector collector = context.getBean(MessageCollector.class); Processor processor = context.getBean(Processor.class); String id = UUID.randomUUID().toString(); processor.input().send( MessageBuilder.withPayload("{\"foo\":\"barbar" + id + "\"}") .setHeader("contentType", "application/json").build()); HandlerBean handlerBean = context.getBean(HandlerBean.class); Assertions.assertThat(handlerBean.receivedPojos).hasSize(1); Assertions.assertThat(handlerBean.receivedPojos.get(0)).hasFieldOrPropertyWithValue("foo", "barbar" + id); Message<String> message = (Message<String>) collector.forChannel( processor.output()).poll(1, TimeUnit.SECONDS); assertThat(message).isNotNull(); assertThat(message.getPayload()).isEqualTo("{\"bar\":\"barbar" + id + "\"}"); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_JSON)); context.close(); }
@Test @SuppressWarnings("unchecked") public void testReturnConversion() throws Exception { ConfigurableApplicationContext context = SpringApplication.run(this.configClass, "--spring.cloud.stream.bindings.output.contentType=application/json", "--server.port=0","--spring.jmx.enabled=false"); MessageCollector collector = context.getBean(MessageCollector.class); Processor processor = context.getBean(Processor.class); String id = UUID.randomUUID().toString(); processor.input().send(MessageBuilder.withPayload("{\"foo\":\"barbar" + id + "\"}") .setHeader("contentType", "application/json").build()); TestPojoWithMimeType testPojoWithMimeType = context.getBean(TestPojoWithMimeType.class); Assertions.assertThat(testPojoWithMimeType.receivedPojos).hasSize(1); Assertions.assertThat(testPojoWithMimeType.receivedPojos.get(0)).hasFieldOrPropertyWithValue("foo", "barbar" + id); Message<String> message = (Message<String>) collector.forChannel(processor.output()).poll(1, TimeUnit.SECONDS); assertThat(message).isNotNull(); assertThat(new String(message.getPayload())).isEqualTo("{\"bar\":\"barbar" + id + "\"}"); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class) .includes(MimeTypeUtils.APPLICATION_JSON)); context.close(); }
@RequestMapping(value = "export") public void exportResponses(@RequestParam String todoUid, HttpServletResponse response) throws IOException { log.info("exporting tood responses .. "); String fileName = "todo_responses.xlsx"; response.setContentType(MimeTypeUtils.APPLICATION_OCTET_STREAM_VALUE); response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\""); response.setHeader("Cache-Control", "no-cache"); response.setHeader("Pragma", "no-cache"); response.setDateHeader("Expires", 0); XSSFWorkbook xls = memberData.exportTodoData(getUserProfile().getUid(), todoUid); log.info("got a workbook back, looks like: {}", xls); xls.write(response.getOutputStream()); response.flushBuffer(); }
@RequestMapping(value = "export-groups", method = RequestMethod.POST) public void exportGroupsDo(@RequestParam String[] selectedGroupUids, HttpServletResponse response) throws IOException { User user = getUserProfile(); user = userManagementService.load(user.getUid()); // take fresh copy in order to have groups added since login List<Group> userGroups = user.getGroups().stream().filter(Group::isActive).sorted(Comparator.comparing(Group::getGroupName)).collect(Collectors.toList()); List<String> userGroupUids = userGroups.stream().map(Group::getUid).collect(Collectors.toList()); XSSFWorkbook xls = memberDataExportBroker.exportMultipleGroupMembers(userGroupUids, Arrays.asList(selectedGroupUids)); String fileName = "multiple_group_members.xlsx"; response.setContentType(MimeTypeUtils.APPLICATION_OCTET_STREAM_VALUE); response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\""); response.setHeader("Cache-Control", "no-cache"); response.setHeader("Pragma", "no-cache"); response.setDateHeader("Expires", 0); xls.write(response.getOutputStream()); response.flushBuffer(); }
protected String getDetectedFormat() { String detectedFormat = null; if (format.equals(FORMAT_AUTOMATIC)) { if (FORMAT_XML.equalsIgnoreCase(context.getFlowParameters().get(FORMAT))) { detectedFormat = FORMAT_XML; } else if (FORMAT_JSON.equalsIgnoreCase(context.getFlowParameters().get(FORMAT))) { detectedFormat = FORMAT_JSON; } else if (MimeTypeUtils.APPLICATION_XML.toString() .equals(context.getFlowParameters().get(HttpHeaders.CONTENT_TYPE))) { detectedFormat = FORMAT_XML; } else if (MimeTypeUtils.APPLICATION_JSON.toString() .equals(context.getFlowParameters().get(HttpHeaders.CONTENT_TYPE))) { detectedFormat = FORMAT_JSON; } else if (MimeTypeUtils.APPLICATION_XML.toString() .equals(context.getFlowParameters().get(HttpHeaders.ACCEPT))) { detectedFormat = FORMAT_XML; } else { detectedFormat = FORMAT_JSON; } } return detectedFormat; }
private AbstractRemoteHandler handlerFor(Method method){ AbstractRemoteHandler handler = remoteHandlers.get(method); if(handler != null){ return handler; } synchronized (remoteHandlers){ ServiceMethodInfo serviceMethodInfo = new ServiceMethodInfo(method); Converter converter = converters.stream().filter(payloadConverter -> payloadConverter.accept(serviceMethodInfo.getMappingInfo().getMimeType())).findFirst().orElseThrow(IllegalStateException::new); Converter metadataConverter = converters.stream().filter(binaryConverter -> binaryConverter.accept(MimeTypeUtils.APPLICATION_JSON)).findFirst().orElseThrow(IllegalStateException::new); switch (serviceMethodInfo.getMappingInfo().getExchangeMode()){ case ONE_WAY: handler = new OneWayRemoteHandler(socket, serviceMethodInfo); remoteHandlers.put(method, handler); break; case REQUEST_ONE: handler = new RequestOneRemoteHandler(socket, serviceMethodInfo); remoteHandlers.put(method, handler); break; case REQUEST_MANY: handler = new RequestManyRemoteHandler(socket, serviceMethodInfo); remoteHandlers.put(method, handler); break; case REQUEST_STREAM: handler = new RequestStreamRemoteHandler(socket, serviceMethodInfo); remoteHandlers.put(method, handler); break; } handler.setPayloadConverter(converter); handler.setMetadataConverter(metadataConverter); } return handler; }
@Override protected Message<?> doConvert(Object payload, Map<String, Object> headers, MessagePostProcessor postProcessor) { String content; if (payload instanceof String) { content = (String) payload; } else { // if payload not as string, use objectMapper change it. try { content = objectMapper.writeValueAsString(payload); } catch (JsonProcessingException e) { log.info("convert payload to String failed. payload:{}", payload); throw new RuntimeException("convert to payload to String failed.", e); } } MessageBuilder<?> builder = MessageBuilder.withPayload(content); if (headers != null) { builder.copyHeaders(headers); } builder.setHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN); Message<?> message = builder.build(); if (postProcessor != null) { message = postProcessor.postProcessMessage(message); } return message; }
@RequestMapping(produces = MimeTypeUtils.TEXT_PLAIN_VALUE) @ResponseBody public String errorTextPlan(HttpServletRequest request) { Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL)); body.put("status", getStatus(request)); return body.toString(); }
private MimeMessage makeEmail(TokenData data, _EmailTemplate template, boolean allowReply) throws IOException, MessagingException { List<_BridgeMessageContent> contents = Arrays.asList( new BridgeMessageContent(MimeTypeUtils.TEXT_PLAIN_VALUE), new BridgeMessageContent(MimeTypeUtils.TEXT_HTML_VALUE) ); return makeEmail(data, template, contents, allowReply); }
protected List<_BridgeMessageContent> extractContent(Part p) throws MessagingException, IOException { if (p.isMimeType("multipart/*")) { log.info("Found multipart content, extracting"); List<_BridgeMessageContent> contents = new ArrayList<>(); Multipart mp = (Multipart) p.getContent(); int count = mp.getCount(); for (int i = 0; i < count; i++) { contents.addAll(extractContent(mp.getBodyPart(i))); } return contents; } if (p.isMimeType("message/rfc822")) { log.info("Found nested content, extracting"); return extractContent((Part) p.getContent()); } String content = p.getContent().toString(); String[] encodings = p.getHeader("Content-Transfer-Encoding"); String encoding = (encodings != null && encodings.length > 0) ? encodings[0] : null; if (StringUtils.equalsIgnoreCase("quoted-printable", encoding)) { try { // TODO actually extract the charset properly // TODO read RFC to know default charset log.info("Transfer encoding is {}, decoding", encoding); content = new String(QuotedPrintableCodec.decodeQuotedPrintable(content.getBytes())); } catch (DecoderException e) { log.warn("Content transfer encoding is set to {} but enable to decode: {}", encoding, e.getMessage()); } } if (p.isMimeType(MimeTypeUtils.TEXT_PLAIN_VALUE)) { log.info("Found plain text content"); return Collections.singletonList(new BridgeMessageTextContent(content, encoding)); } if (p.isMimeType(MimeTypeUtils.TEXT_HTML_VALUE)) { log.info("Found HTML content"); return Collections.singletonList(new BridgeMessageHtmlContent(content, encoding)); } return Collections.emptyList(); }
/** * Called by rocket.chat plugins to get the conversationId for the clientId and channelId known to the plugin. * The returned conversationID can later be used for calls to the {@link ConversationWebservice} * @param clientName the client id * @param channelId the channelId * @return a <code>200</code> with the conversation id as payload or a <code>404</code> if no conversation is * active for the parsed parameters. */ @ApiOperation(value = "retrieve a conversation ID for a channel and client id", nickname = "rocketGetConversation", produces=MimeTypeUtils.TEXT_PLAIN_VALUE ) @RequestMapping(value = "{clientId}/{channelId}/conversationid", method = RequestMethod.GET, produces=MimeTypeUtils.TEXT_PLAIN_VALUE, consumes=MimeTypeUtils.ALL_VALUE) public ResponseEntity<?> getConversation( AuthContext authContext, @PathVariable(value="clientId") String clientName, @PathVariable(value="channelId") String channelId) { if (log.isTraceEnabled()) { log.debug("{}[{}]: lookup conversation-id of {}", clientName, authContext, channelId); } else { log.debug("{}: lookup conversation-id of {}", clientName, channelId); } Client client = clientService.getByName(clientName); if(client == null || !authenticationService.hasAccessToClient(authContext, client.getId())){ return ResponseEntity.notFound().build(); } Conversation conversation = conversationService.getCurrentConversationByChannelId( client, createChannelId(client, channelId),() -> null); //do not create new conversations if (conversation == null || conversation.getId() == null) { return ResponseEntity.notFound().build(); } else { return ResponseEntity.ok(conversation.getId().toHexString()); } }
@ApiOperation(value = "append a message to the conversation", response = Conversation.class) @RequestMapping(value = "{id}/message", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<?> addMessage( AuthContext authContext, @PathVariable("id") ObjectId id, @RequestBody Message message ) { final Conversation conversation = authenticationService.assertConversation(authContext, id); final Client client = authenticationService.assertClient(authContext, conversation.getOwner()); return ResponseEntity.ok(conversationService.appendMessage(client, conversation, message)); }
@ApiOperation(value = "update a query based on new slot-assignments", response = Query.class) @RequestMapping(value = "{id}/query/{template}/{creator}", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<?> getQuery( AuthContext authContext, @PathVariable("id") ObjectId id, @PathVariable("template") int templateIdx, @PathVariable("creator") String creator, @ApiParam(hidden = true) @RequestParam(required = false) MultiValueMap<String, String> params, @RequestBody QueryUpdate queryUpdate ) { final Conversation conversation = authenticationService.assertConversation(authContext, id); final Client client = authenticationService.assertClient(authContext, conversation.getOwner()); final Configuration clientConf = configService.getClientConfiguration(client.getId()); if(clientConf == null){ log.info("Client {} of Conversation {} has no longer a configuration assigned ... returning 404 NOT FOUND", conversation.getChannelId(), conversation.getId()); return ResponseEntity.notFound().build(); } final Template template = conversation.getTemplates().get(templateIdx); if (template == null) return ResponseEntity.notFound().build(); //NOTE: conversationService.getConversation(..) already update the queries if necessary //so at this place we only need to retrieve the requested query Optional<Query> query = template.getQueries().stream().filter(q -> Objects.equals(creator, q.getCreator())).findFirst(); return query.isPresent() ? ResponseEntity.ok(query.get()) : ResponseEntity.notFound().build(); }
@RequestMapping(value = "/user", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<SmartiUserData> createUser(AuthContext authContext, @RequestBody SmartiUserData user) { authenticationService.assertRole(authContext, AuthenticationService.ADMIN); if (StringUtils.isBlank(user.getLogin())) { return ResponseEntity.unprocessableEntity().build(); } return ResponseEntity.ok(SmartiUserData.fromModel(userService.createUser(user.toModel()))); }
@RequestMapping(value = "/user/{login}", method = RequestMethod.PUT, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public SmartiUserData updateUser(AuthContext authentication, @PathVariable("login") String login, @RequestBody SmartiUserData user) { // Access only for ADMIN or @me if (authenticationService.hasLogin(authentication, login) || authenticationService.hasRole(authentication, AuthenticationService.ADMIN)) { return SmartiUserData.fromModel(userService.updateProfile(login, user.getProfile())); } else { throw new AccessDeniedException("No access for " + authentication); } }
@ApiOperation(value = "import conversations") @RequestMapping(value = "import", method = RequestMethod.POST, consumes = MimeTypeUtils.APPLICATION_JSON_VALUE) public ResponseEntity<?> importConversations( AuthContext authContext, @RequestParam("owner") ObjectId owner, @RequestParam(value = "replace", defaultValue = "false", required = false) boolean replace, @RequestBody List<Conversation> conversations ) { if (authenticationService.hasAccessToClient(authContext, owner)) { conversationService.importConversations(owner, conversations, replace); return ResponseEntity.noContent().build(); } else { return ResponseEntity.badRequest().build(); } }
void updateSimpMessageHeadersFromStompHeaders() { if (getNativeHeaders() == null) { return; } String value = getFirstNativeHeader(STOMP_DESTINATION_HEADER); if (value != null) { super.setDestination(value); } value = getFirstNativeHeader(STOMP_CONTENT_TYPE_HEADER); if (value != null) { super.setContentType(MimeTypeUtils.parseMimeType(value)); } StompCommand command = getCommand(); if (StompCommand.MESSAGE.equals(command)) { value = getFirstNativeHeader(STOMP_SUBSCRIPTION_HEADER); if (value != null) { super.setSubscriptionId(value); } } else if (StompCommand.SUBSCRIBE.equals(command) || StompCommand.UNSUBSCRIBE.equals(command)) { value = getFirstNativeHeader(STOMP_ID_HEADER); if (value != null) { super.setSubscriptionId(value); } } else if (StompCommand.CONNECT.equals(command)) { protectPasscode(); } }