/// <summary>
        /// The GetIntegrationEvent
        /// </summary>
        /// <param name="message">The message<see cref="CoreMessage"/></param>
        /// <returns>The <see cref="IntegrationEvent"/></returns>
        private IntegrationEvent GetIntegrationEvent(CoreMessage message)
        {
            string jsonstring = Encoding.UTF8.GetString(message.Body);

            DcpMessage dcpMessage = JsonConvert.DeserializeObject <DcpMessage>(jsonstring);

            IntegrationEvent integrationEvnt = SetIntegrationEventProperties(message);

            integrationEvnt.Body = dcpMessage;

            return(integrationEvnt);
        }
Esempio n. 2
0
        /// <summary>
        /// The OnWait
        /// </summary>


        /// <summary>
        /// Return valid or Invalid item collection
        /// </summary>
        /// <param name="dcpMessage">The DcpMessage<see cref="DcpMessage"/></param>
        /// <param name="paths">collection of path<see cref="List{String}"/></param>
        /// <returns>The <see cref="List{Item}"/></returns>
        private static List <Item> GetItemCollection(List <string> paths, DcpMessage dcpMessage)
        {
            List <Item> items = new List <Item>();

            paths.ForEach(path =>
            {
                items.Add(
                    new Item
                {
                    ItemId     = dcpMessage.ServiceOutput.Items[0].ItemId,
                    ItemPath   = path,
                    InlineData = new[] { string.Empty }
                }
                    );
            });

            return(items);
        }
Esempio n. 3
0
        /// <summary>
        /// The OnProcessAsync
        /// </summary>
        /// <param name="message">The message<see cref="CoreMessage"/></param>
        /// <returns>The <see cref="MessageProcessResponse"/></returns>
        public async Task <MessageProcessResponse> OnProcessAsync(CoreMessage message)
        {
            try
            {
                Guard.AgainstNull(nameof(message.Body), message?.Body);
                string msgBody = Encoding.UTF8.GetString(message?.Body);
                MessageProcessResponse messageProcessResponse = MessageProcessResponse.Abandon;
                Log.DependencyTrackingTelemetryModule();
                DcpMessage dcpMessage = JsonConvert.DeserializeObject <DcpMessage>(msgBody);

                Dictionary <string, Func <IBusinessValidationStrategy> > strategies = getStrategy.GetListOfStrategy(mediator);

                Domain.Model.BusinessValidationProxy businessValidationProxy = await strategies[dcpMessage.ServiceOutput.Items[0].ItemId.ToUpperInvariant()]()
                                                                               .ExecuteStrategy(dcpMessage.ServiceOutput.Items[0].ItemId, dcpMessage.ServiceOutput.Items[0]);

                if (businessValidationProxy.Valid)
                {
                    List <Item> validItems = GetItemCollection(businessValidationProxy.ValidPaths, dcpMessage);

                    if (validItems != null && validItems.Count > 0)
                    {
                        messageProcessResponse = await mediator.Send(new SendServiceOutPutMessageCommand(validItems, message, businessValidationProxy.Valid, businessValidationProxy.ErrorMessages));
                    }
                }

                List <Item> invalidItems = GetItemCollection(businessValidationProxy.InValidPaths, dcpMessage);

                if (invalidItems != null && invalidItems.Count > 0)
                {
                    businessValidationProxy.InValid = false;
                    messageProcessResponse          = await mediator.Send(new SendServiceOutPutMessageCommand(invalidItems, message, businessValidationProxy.InValid, businessValidationProxy.ErrorMessages));
                }

                return(messageProcessResponse);
            }

            catch (Exception ex)
            {
                Log.Error(ex.Message);
                return(MessageProcessResponse.Abandon);
            }
        }