Example #1
0
        public static bool MatchEntryCriteria(ChannelInitializationParameter param, MessagePackage msgPackage, MessageEntryConfig cfg)
        {
            if (msgPackage == null ||
                msgPackage.OriginalMessage == null ||
                msgPackage.OriginalMessage.Header == null ||
                cfg == null || param == null)
            {
                return(false);
            }

            if (msgPackage.IsAccepted())
            {
                param.Log.Write(LogType.Information,
                                string.Format("The message package {0} has been accepted by other channel.",
                                              msgPackage.OriginalMessage.Header.ToString()));
                return(false);
            }

            bool res = false;

            switch (cfg.CheckingModel)
            {
            default:
            case MessageEntryCheckingModel.AcceptAnyUnacceptedMessage:
            {
                res = true;
                break;
            }

            case MessageEntryCheckingModel.AcceptUnacceptedMessageAccordingToMessageType:
            {
                res = cfg.EntryMessageType.EqualsTo(msgPackage.OriginalMessage.Header.Type);
                break;
            }

            case MessageEntryCheckingModel.AcceptUnacceptedMessageAccordingToEntryCriteria:
            {
                res = MatchEntryCriteria(param.Log, msgPackage.GetMessageXml(), cfg.EntryCriteria);
                break;
            }
            }

            if (res)
            {
                msgPackage.Accept(param.ChannelName);
            }

            return(res);
        }
Example #2
0
        public ChannelProcessResult ProcessResponserMessage(MessagePackage request, out MessagePackage response)
        {
            response = null;

            if (MessageEntryHelper.MatchEntryCriteria(_param, request, _config.EntryControl))
            {
                if (_pipeLineReq.Process(request))
                {
                    string  reqXml = request.GetMessageXml();
                    Message reqMsg = XObjectManager.CreateObject <Message>(reqXml);
                    if (reqMsg == null)
                    {
                        return(ChannelProcessResult.ProcessingError);
                    }

                    reqMsg.Header.ID   = Guid.NewGuid();
                    reqMsg.Header.Type = _config.RequestMessageTypePair.RequestMessageType;

                    Message rspMsg = null;
                    if (_param.Sender.NotifyMessageRequest(reqMsg, out rspMsg) &&
                        rspMsg != null && rspMsg.Header != null)
                    {
                        if (!_config.RequestMessageTypePair.ResponseMessageType.EqualsTo(rspMsg.Header.Type))
                        {
                            _param.Log.Write(LogType.Error,
                                             "Receiving response message is not the type of :"
                                             + _config.RequestMessageTypePair.ResponseMessageType.ToString());
                            return(ChannelProcessResult.SendingError);
                        }

                        rspMsg.Header.ID   = Guid.NewGuid();
                        rspMsg.Header.Type = _config.ResponseMessageType;

                        string rspXml = rspMsg.ToXMLString();
                        response = new MessagePackage(rspMsg, rspXml);
                        response.Accept(_param.ChannelName);

                        if (_pipeLineRsp.Process(response))
                        {
                            return(ChannelProcessResult.Success);
                        }
                        else
                        {
                            return(ChannelProcessResult.ProcessingError);
                        }
                    }
                    else
                    {
                        return(ChannelProcessResult.SendingError);
                    }
                }
                else
                {
                    return(ChannelProcessResult.ProcessingError);
                }
            }
            else
            {
                return(ChannelProcessResult.NotMatchEntryCriteria);
            }
        }