错误：全局的

@param message

@return
500460
protected JsonObjectBase buildGlobalError(String message, ErrorCode errorCode) {

        return JsonObjectUtils.buildGlobalError(message, errorCode);
    }
248749
public CallActivityMock onExecutionSendMessage(final String message) {
    return onExecutionDo(execution -> execution.getProcessEngineServices()
      .getRuntimeService().correlateMessage(message));
  }
1326872
public BaseMessage processMessage(BaseMessage message)
    {
        if (message == null)
            return null;
        this.updateLogFiles(message, true);  // Need to change log status to SENTOK (also associate return message log trx ID) (todo)
        String strReturnQueueName = null;
        if (message.getMessageHeader() instanceof TrxMessageHeader)
            strReturnQueueName = (String)((TrxMessageHeader)message.getMessageHeader()).getMessageHeaderMap().get(MessageConstants.RETURN_QUEUE_NAME);
        if (strReturnQueueName == null)
            strReturnQueueName = MessageConstants.TRX_RETURN_QUEUE;
        TrxMessageHeader privateMessageHeader = new TrxMessageHeader(strReturnQueueName, MessageConstants.INTERNET_QUEUE, null);
        if (message.getMessageHeader().getRegistryIDMatch() == null)
        {   // The registry is probably in the message header
            Integer intRegistryID = this.getRegistryID(message);
            if (intRegistryID != null)
                message.getMessageHeader().setRegistryIDMatch(intRegistryID);
        }
        privateMessageHeader.setRegistryIDMatch(message.getMessageHeader().getRegistryIDMatch());
        message.setMessageHeader(privateMessageHeader);

        Environment env = null;
        if ((this.getTask() != null)
            && (this.getTask().getApplication() != null))
                env = ((BaseApplication)this.getTask().getApplication()).getEnvironment();
        if (env == null)
            env = Environment.getEnvironment(null);
        App app = null;
        if (this.getTask() != null)
        	app = this.getTask().getApplication();
        MessageManager msgManager = env.getMessageManager(app, true);
        msgManager.sendMessage(message);
        return null;
    }
493494
public Event mapToEvent(Message message) {
        Event event = new Event();
        MessageInfo messageInfo = new MessageInfo();
        Originator originator = new Originator();
        boolean isRestMessage = isRestMessage(message);

        event.setMessageInfo(messageInfo);
        event.setOriginator(originator);
        String content = getPayload(message);
        event.setContent(content);
        handleContentLength(event);
        event.setEventType(null);
        Date date = new Date();
        event.setTimestamp(date);

//        if (isRestMessage) {
//            String queryString = (String) message.get(Message.QUERY_STRING);
//            if (queryString == null && message.getExchange().getInMessage() != null) {
//                queryString = (String) message.getExchange().getInMessage().get(Message.QUERY_STRING);
//            }
//            if (queryString != null && queryString.contains("_wadl")) {
//                return null;
//            }
//        }

        messageInfo.setFlowId(FlowIdHelper.getFlowId(message));
        if (!isRestMessage) {
            messageInfo.setMessageId(getMessageId(message));
            ServiceInfo serviceInfo = message.getExchange().getBinding().getBindingInfo().getService();
            if (null != serviceInfo) {
                String portTypeName = serviceInfo.getInterface().getName().toString();
                messageInfo.setPortType(portTypeName);
                messageInfo.setOperationName(getOperationName(message));
            }
            SoapBinding soapBinding = (SoapBinding) message.getExchange().getBinding();
            if (soapBinding.getBindingInfo() instanceof SoapBindingInfo) {
                SoapBindingInfo soapBindingInfo = (SoapBindingInfo) soapBinding.getBindingInfo();
                messageInfo.setTransportType(soapBindingInfo.getTransportURI());
            }
        } else {
            messageInfo.setTransportType("http://cxf.apache.org/transports/http");
            messageInfo.setPortType(message.getExchange().getEndpoint().getEndpointInfo().getName()
                    .toString());
            String opName = getRestOperationName(message);
            messageInfo.setOperationName(opName);
        }

        if (messageInfo.getTransportType() == null) {
            messageInfo.setTransportType("Unknown transport type");
        }

        // add custom properties from CXF properties
        if (null != message.getExchange().getEndpoint().get(EventFeature.SAM_PROPERTIES)) {
            Map<String, String> customProp =
                    (Map<String, String>) message.getExchange().getEndpoint().get(EventFeature.SAM_PROPERTIES);
            event.getCustomInfo().putAll(customProp);
        }

        String addr = message.getExchange().getEndpoint().getEndpointInfo().getAddress();
        if (null != addr) {
            event.getCustomInfo().put("address", addr);
        }

        String correlationId = CorrelationIdHelper.getCorrelationId(message);
        if (null != correlationId) {
            event.getCustomInfo().put("CorrelationID", correlationId);
        }

        try {
            InetAddress inetAddress = InetAddress.getLocalHost();
            originator.setIp(inetAddress.getHostAddress());
            originator.setHostname(inetAddress.getHostName());
        } catch (UnknownHostException e) {
            originator.setHostname("Unknown hostname");
            originator.setIp("Unknown ip address");
        }
        originator.setProcessId(Converter.getPID());

        if (isRestMessage) {
            //String queryString = (String) message.get(Message.QUERY_STRING);
            //if (null == queryString && null != message.getExchange().getInMessage()) {
            //    queryString = (String) message.getExchange().getInMessage().get(Message.QUERY_STRING);
            //}
            //if (null != queryString) {
            //    event.getCustomInfo().put("Query String", queryString);
            //}

            String accept = (String) message.get(Message.ACCEPT_CONTENT_TYPE);
            if (null != accept) {
                event.getCustomInfo().put("Accept Type", accept);
            }

            //String httpMethod = (String) message.get(Message.HTTP_REQUEST_METHOD);
            //if (null != httpMethod) {
            //    event.getCustomInfo().put("HTTP Method", httpMethod);
            //}

            String contentType = (String) message.get(Message.CONTENT_TYPE);
            if (null != contentType) {
                event.getCustomInfo().put("Content Type", contentType);
            }

            Integer responseCode = (Integer) message.get(Message.RESPONSE_CODE);
            if (null != responseCode) {
                event.getCustomInfo().put("Response Code", responseCode.toString());
            }
        }

        SecurityContext sc = message.get(SecurityContext.class);
        if (sc != null && sc.getUserPrincipal() != null) {
            originator.setPrincipal(sc.getUserPrincipal().getName());
        }

        if (originator.getPrincipal() == null) {
            AuthorizationPolicy authPolicy = message.get(AuthorizationPolicy.class);
            if (authPolicy != null) {
                originator.setPrincipal(authPolicy.getUserName());
            }
        }

        EventTypeEnum eventType = getEventType(message);
        event.setEventType(eventType);

        CustomInfo customInfo = CustomInfo.getOrCreateCustomInfo(message);
        // System.out.println("custom props: " + customInfo);
        event.getCustomInfo().putAll(customInfo);

        return event;
    }
781412
public int sendMessage(Message message)
    {
        BaseMessageHeader messageHeader = ((BaseMessage)message).getMessageHeader();
        String strQueueType = messageHeader.getQueueType();
        String strQueueName = messageHeader.getQueueName();
        MessageSender sender = this.getMessageQueue(strQueueName, strQueueType).getMessageSender();
        if (sender != null)
            sender.sendMessage(message);
        else
            return Constant.ERROR_RETURN;  // Queue doesn't exist
        return Constant.NORMAL_RETURN;
    }
1275038
protected final <T> T readMessage(String message, Class<T> clazz) {
		if ((message == null) || message.isEmpty()) {
			ClientSocketAdapter.LOGGER.info("Got empty session data");
			return null;
		}
		try {
			return this.mapper.readValue(message, clazz);
		} catch (IOException e1) {
			ClientSocketAdapter.LOGGER.info("Got invalid session data", e1);
			return null;
		}
	}
292626
public static ExecutionResult success(String message) {
        ExecutionResult executionResult = new ExecutionResult();
        executionResult.withSuccessMessages(message);
        return executionResult;
    }
1140998
public Class<?> getBody(String message) {
		final Set<IdentifierLine> identifierLines = this.definitions.keySet();
		final IdentifierLine messageId =  new IdentifierLine();
		for(IdentifierLine id : identifierLines){
			final Map<Integer, String> mapIds = id.getMapIds();
			final Set<Integer> keys = mapIds.keySet();
			for (Integer startPosition :  keys){
				final String textId = mapIds.get(startPosition);
				int sizeText =  textId.length();
				int finalPosition =  startPosition + sizeText;
				if (finalPosition > message.length()){
					break;
				}
				messageId.putId(startPosition, message.substring(startPosition, finalPosition));
			}
			if (id.equals(messageId)){
				this.body = this.definitions.get(messageId);
				break;
			}else{
				messageId.getMapIds().clear();
			}
		}
		if (this.body == null){
			throw new FFPojoException(String.format("No class matches with the line starting with:  %s ", getStartWithText(message)));
		}

		return this.body;
	}
627401
public byte [] detached(byte [] message) {
            byte[] signedMsg = this.sign(message);
            byte[] sig = new byte[signatureLength];
            for (int i = 0; i < sig.length; i++)
                sig[i] = signedMsg[i];
            return sig;
        }
269405
public static String getFirstLine(final String message) {
		if (isEmpty(message)) {
			return message;
		}
		if (message.contains("\n")) {
			return message.split("\n")[0];
		}
		return message;
	}
349686
public String getMessage(String message, Object[] args)
    {
        for (int i=0;i<args.length;i++)
        {
            if (args[i] instanceof List<?>)
            {
                @SuppressWarnings("unchecked")
				List<ProxyField> list = (List<ProxyField>)args[i];
                StringBuilder sb = new StringBuilder();
                for (ProxyField pf: list)
                {
                    sb.append(String.valueOf(pf.getValue()));
                    sb.append(",");
                }
                if (sb.length()>0)
                {
                    args[i] = sb.substring(0, sb.length()-1);
                }
                else
                {
                    args[i] = "";
                }
            }
        }
        return m_messageSourceAccessor.getMessage(message, args);
    }
1009860
public static StringBuilder concat(final String... message) {
        final StringBuilder builder = new StringBuilder();
        for (final String mess : message) {
            builder.append(mess);
            builder.append(" ");
        }
        return builder;
    }
959292
public String getMessageProcessorClassName(BaseMessage message)
    {
        String strClass = (String)message.getMessageHeader().get(DBParams.PROCESS);
        if ((strClass == null)
            || (strClass.length() == 0))
        {
            String strMessageCode = (String)message.getMessageHeader().get(BaseMessageHeader.MESSAGE_CODE);
            if ((strMessageCode == null)
                || (strMessageCode.length() == 0))
                    strMessageCode = (String)message.get(BaseMessageHeader.MESSAGE_CODE);
            if (strMessageCode != null)
                if (strMessageCode.length() > 0)
                    if (message instanceof BaseMessage)
            {
                MessageProcessInfoModel recMessageProcessInfo = (MessageProcessInfoModel)Record.makeRecordFromClassName(MessageProcessInfoModel.THICK_CLASS, (RecordOwner)m_application.getSystemRecordOwner()); // todo(don) Not the most efficent sharing! Note: Remember the import
                recMessageProcessInfo.setupMessageHeaderFromCode((BaseMessage)message, strMessageCode, null);
                recMessageProcessInfo.free();
                strClass = (String)message.getMessageHeader().get(DBParams.PROCESS);
            }
        }
        String strPackage = (String)message.getMessageHeader().get(BaseMessageHeader.BASE_PACKAGE);
        if (strPackage != null)
            if (strPackage.length() > 0)
                if (strPackage.charAt(strPackage.length() - 1) != '.')
                    strPackage = strPackage + '.';
        if ((strClass == null) || (strClass.length() == 0))
            strClass = m_strProcessClassName;
        if (strClass != null)
            if (strClass.length() > 0)
        {
            if (strClass.indexOf('.') == -1)
                if (strPackage != null)
                    strClass = strPackage + strClass;
            if (strClass.charAt(0) == '.')
                strClass = DBConstants.ROOT_PACKAGE + strClass.substring(1);
        }
        return strClass;
    }
512335
public String input(String message) throws IOException, UserCancelExcption {
		Map<String, Object> m = JSONProtocol.cmd("input");
		m.put("text", message);
		pipe.send(m);
		Map<String, Object> r = pipe.recv();
		if (!JSONProtocol.check(m, r) || !r.containsKey("value")) {
			throw new IOException("No value");
		}
		return (String) r.get("value");
	}
493793
public synchronized byte[] mac(byte[] message) {
        ConfidentialStore cs = ConfidentialStore.get();
        if (mac == null || cs != lastCS) {
            lastCS = cs;
            mac = createMac();
        }
        return chop(mac.doFinal(message));
    }
290887
public B message(String messageName) {
    Message message = findMessageForName(messageName);
    return message(message);
  }
725446
private String formatMessage(final String message) {
        if (null != reformatter) {
            return reformatter.reformat(context, message);
        } else {
            return message;
        }
    }