@Override public void assignValue(String name, Object value, Object newValue) { muleMessage.setPayload(newValue); } });
public void setPayload(Object payload) { message.setPayload(payload); }
public void setPayload(Object payload) { message.setPayload(payload); }
private MuleMessage createMessage(Object payload, MuleMessage originalMessage) { if (payload instanceof MuleMessage) { return (MuleMessage) payload; } MuleMessage message = new DefaultMuleMessage(originalMessage, muleContext); message.setPayload(payload); return message; }
private void updateSoapEnvelope(String xml) { log.debug("New payload: \n" + xml); cachedObject.getMessage().setPayload(xml); } }
private void transformBack(MuleMessage message) throws TransformerException { message.setPayload(message.getPayload(DataType.STRING_DATA_TYPE)); }
private boolean transformPayloadIfNeeded(MuleMessage message) throws TransformerException { Object payload = message.getPayload(); if (payload instanceof Document || payload.getClass().getName().startsWith("org.dom4j.")) { return false; } message.setPayload(message.getPayload(DataTypeFactory.create(Document.class))); return true; }
@Override protected MuleEvent processRequest(MuleEvent event) throws MuleException { /* * If the requestBody variable is set, it will be used as the payload to send instead of the payload of * the message. This will happen when an operation required no input parameters. */ if (requestBody != null) { event.getMessage().setPayload(requestBody); } copyAttachmentsRequest(event); return super.processRequest(event); }
@Override protected boolean doPropagate(MuleMessage message, TypedValue typedValue, ASTNode node) { if (node instanceof Assignment) { String assignmentVar = ((Assignment) node).getAssignmentVar(); if (PAYLOAD.equals(assignmentVar) || MESSAGE_PAYLOAD.equals(assignmentVar)) { message.setPayload(typedValue.getValue(), typedValue.getDataType()); return true; } } return false; }
/** * Gets an XMLStreamReader for this message. * * @param message * @throws TransformerException */ protected ReversibleXMLStreamReader getXMLStreamReader(MuleMessage message) throws TransformerException { ReversibleXMLStreamReader r = (ReversibleXMLStreamReader) transformer.transform(message); if (r != message.getPayload()) { message.setPayload(r); } return r; }
@Override public void acceptValue(Object value) { this.muleEvent.getMessage().setPayload(value); try { Serializable evaluated = WatermarkUtils.evaluate(this.selectorExpression, muleEvent); this.wrapped.acceptValue(evaluated); } catch (NotSerializableException e) { logger.warn( String.format( "Watermark selector expression '%s' did not resolved to a Serializable value. Value will be ignored", this.selectorExpression), e); } }
private HttpResponse buildFailureResponse(MuleEvent event, String description, int httpStatusCode) throws MuleException { event.getMessage().setOutboundProperty(HttpConnector.HTTP_STATUS_PROPERTY,httpStatusCode); event.getMessage().setPayload(description); return transformResponse(event.getMessage(), event); }
@Override public MuleEvent process(MuleEvent event) throws MuleException { if (StringUtils.isEmpty(mimeType) && StringUtils.isEmpty(encoding)) { final TypedValue typedValue = resolveTypedValue(event); event.getMessage().setPayload(typedValue.getValue(), typedValue.getDataType()); } else { Object value = resolveValue(event); DataType dataType = resolveDataType(event, value); event.getMessage().setPayload(value, dataType); } return event; }
private String getIdForEvent(MuleEvent event) throws Exception { if (useSecureHash) { Object payload = event.getMessage().getPayload(); byte[] bytes = (byte[]) objectToByteArray.transform(payload); if (payload instanceof InputStream) { // We've consumed the stream. event.getMessage().setPayload(bytes); } MessageDigest md = MessageDigest.getInstance(messageDigestAlgorithm); byte[] digestedBytes = md.digest(bytes); return (String)byteArrayToHexString.transform(digestedBytes); } else { return event.getMuleContext().getExpressionManager().parse(idExpression, event, true); } }
/** * Message aware transformer that ... */ @Override public Object transformMessage(MuleMessage message, String outputEncoding) throws TransformerException { // Perform any message aware processing here, otherwise delegate as much as possible to pojoTransform() for easier unit testing QueryObject queryObject = (QueryObject)message.getInvocationProperty("queryObject"); //return pojoTransform(queryObject, message.getPayload(), outputEncoding); PojoTransformResult ptr = pojoTransform(queryObject, message.getPayload(), outputEncoding); // set ProcessingStatus result as properties for log tracking message.setInvocationProperty(AgpLoggingProperties.PROCESSINGSTATUS_COUNT_TOTAL, String.valueOf(ptr.procStatusLogFormat.getProcStatusCountTot())); message.setInvocationProperty(AgpLoggingProperties.PROCESSINGSTATUS_COUNT_FAIL, String.valueOf(ptr.procStatusLogFormat.getProcStatusCountFail())); message.setInvocationProperty(AgpLoggingProperties.PROCESSINGSTATUS, ptr.procStatusLogFormat.getProcStatus()); message.setPayload(ptr.xml); return message; }
private void sendFailureResponseToClient(MessagingException exception, int httpStatus) throws IOException, MuleException { MuleEvent response = exception.getEvent(); response.getMessage().setPayload(exception.getMessage()); httpStatus = response.getMessage().getOutboundProperty(HttpConnector.HTTP_STATUS_PROPERTY) != null ? Integer.valueOf(response.getMessage().getOutboundProperty(HttpConnector.HTTP_STATUS_PROPERTY).toString()) : httpStatus; response.getMessage().setOutboundProperty(HttpConnector.HTTP_STATUS_PROPERTY, httpStatus); HttpResponse httpResponse = transformResponse(response.getMessage()); httpServerConnection.writeResponse(httpResponse, getThrottlingHeaders()); }
/** * Stores the response payload (body of the HTTP response) in the Mule message according to the "target" * property. If empty, it will be stored in the payload. If not, it will use the target expression to enrich * the message with the body of the response. */ private void setResponsePayload(Object payload, MuleEvent muleEvent) { if (StringUtils.isEmpty(requester.getTarget()) || DEFAULT_PAYLOAD_EXPRESSION.equals(requester.getTarget()) ) { muleEvent.getMessage().setPayload(payload, muleEvent.getMessage().getDataType()); } else { muleContext.getExpressionManager().enrich(requester.getTarget(), muleEvent, payload); } }
/** * @param event the response event from the until-successful route. * @return the response message to be sent to the until successful caller. */ protected MuleEvent processResponseThroughAckResponseExpression(MuleEvent event) { if (event == null || VoidMuleEvent.getInstance().equals(event)) { return VoidMuleEvent.getInstance(); } if (untilSuccessfulConfiguration.getAckExpression() == null) { return event; } event.getMessage().setPayload(getUntilSuccessfulConfiguration().getMuleContext().getExpressionManager() .evaluate(getUntilSuccessfulConfiguration().getAckExpression(), event)); return event; }
@Override public MuleEvent process(MuleEvent event) throws MuleException { MuleMessage msg = event.getMessage(); HttpResponse httpResponse = getHttpResponse(msg); propagateMessageProperties(httpResponse, msg); checkVersion(msg); setStatus(httpResponse, msg); setContentType(httpResponse, msg); setHeaders(httpResponse, msg); setCookies(httpResponse, msg); setCacheControl(httpResponse, msg); setDateHeader(httpResponse, new Date()); setBody(httpResponse, msg, event); msg.setPayload(httpResponse); return event; }
@Override public void sendFailureResponseToClient(MessagingException messagingException, ResponseCompletionCallback responseCompletationCallback) throws MuleException { //For now let's use the HTTP transport exception mapping since makes sense and the gateway depends on it. String exceptionStatusCode = ExceptionHelper.getTransportErrorMapping(HTTP.getScheme(), messagingException.getClass(), sourceMuleEvent.getMuleContext()); Integer statusCodeFromException = exceptionStatusCode != null ? Integer.valueOf(exceptionStatusCode) : INTERNAL_SERVER_ERROR_STATUS_CODE; final org.mule.module.http.internal.domain.response.HttpResponseBuilder failureResponseBuilder = new org.mule.module.http.internal.domain.response.HttpResponseBuilder() .setStatusCode(statusCodeFromException) .setReasonPhrase(messagingException.getMessage()); addThrottlingHeaders(failureResponseBuilder); MuleEvent event = messagingException.getEvent(); event.getMessage().setPayload(messagingException.getMessage()); final HttpResponse response = errorResponseBuilder.build(failureResponseBuilder, event); responseReadyCallback.responseReady(response, getResponseFailureCallback(responseCompletationCallback, messagingException.getEvent())); }