public void Publish_CallsPublish()
        {
            var message = new MessageRoutingSystemError();
            _bus.Publish(message);

            _mockBusControl.Verify(x => x.Publish(message, CancellationToken.None));
        }
        public void Send(MessageRoutingSystemError message, bool isPool = false, MailPriority priority = MailPriority.Normal)
        {
            try
            {
                var body = GenerateHtml(message, isPool);

                using (var mailMessage = new MailMessage())
                {
                    mailMessage.From = new MailAddress(FromAddress);

                    // Add recipients
                    if (!string.IsNullOrWhiteSpace(ToAddress))
                    {
                        ToAddress.Split(';').ToList().ForEach(x => mailMessage.To.Add(x));
                    }
                    else
                    {
                        var defaultDelivery = ConfigurationManager.AppSettings["DefaultDelivery"];
                        defaultDelivery.Split(';').ToList().ForEach(x => mailMessage.To.Add(x));
                    }

                    mailMessage.Priority = priority;
                    mailMessage.Body = body;
                    mailMessage.IsBodyHtml = true;
                    mailMessage.Subject = string.IsNullOrWhiteSpace(Subject) ? $"Error Occurred in Application '{message.ApplicationName}'" : Subject;

                    var smtpClient = new SmtpClient()
                    {
                        Host = Host,
                        Port = Port,
                        UseDefaultCredentials = false,
                        EnableSsl = true
                    };

                    var networkCredentials = new NetworkCredential
                    {
                        UserName = Username,
                        Password = Password
                    };

                    smtpClient.Credentials = networkCredentials;
                    smtpClient.Send(mailMessage);
                }
            }
            catch (Exception e)
            {

            }
        }
        private string GenerateHtml(MessageRoutingSystemError message, bool isPool)
        {
            string body;

            using (var reader = new StreamReader("EmailTemplate.html"))
            {
                body = reader.ReadToEnd();
            }

            body = body.Replace("{MessagePool}", isPool ? "This error message was part of a message pool. Please check the MRS Manager for details." : "");
            body = body.Replace("{Subject}", Subject);
            body = body.Replace("{ApplicationName}", message.ApplicationName);
            body = body.Replace("{MachineName}", message.MachineName);
            body = body.Replace("{ExceptionType}", message.ExceptionType);
            body = body.Replace("{ExceptionMessage}", message.ExceptionMessage);
            body = body.Replace("{StackTrace}", message.StackTrace);
            body = body.Replace("{CommandLineArgs}", message.CommandLineArgs);
            body = body.Replace("{HelpText}", message.HelpText);

            return body;
        }
 /// <summary>
 /// Print the error to the console (helpful for debugging)
 /// </summary>
 /// <param name="error"></param>
 private static void PrintError(MessageRoutingSystemError error)
 {
     Console.WriteLine("================================");
     Console.WriteLine("= Message Routing System Error =");
     Console.WriteLine("================================");
     Console.WriteLine("  Application Name: " + error.ApplicationName);
     Console.WriteLine("  Machine Name: " + error.MachineName);
     Console.WriteLine("  Exception Type: " + error.ExceptionType);
     Console.WriteLine("  Exception Message: " + error.ExceptionMessage);
     Console.WriteLine("  Insert Date: " + error.InsertDate);
     Console.WriteLine("\r\n");
 }
 /// <summary>
 /// Deliver an error to the default recipient
 /// </summary>
 /// <param name="message"></param>
 private static void DefaultDelivery(MessageRoutingSystemError message)
 {
     var emailer = new EmailClient(null, null);
     emailer.Send(message);
 }
 /// <summary>
 /// Check if a rule matches a message
 /// </summary>
 /// <param name="rule"></param>
 /// <param name="message"></param>
 /// <returns></returns>
 public bool IsMatch(RuleDto rule, MessageRoutingSystemError message)
 {
     return CheckApplicationGroupMatch(rule.ApplicationGroupId, message.ApplicationName) &&
            CheckMachineGroupMatch(rule.MachineGroupId, message.MachineName) &&
            CheckRuleMatch(rule.ApplicationName, message.ApplicationName) &&
            CheckRuleMatch(rule.MachineName, message.MachineName) &&
            CheckRuleMatch(rule.HelpText, message.HelpText) &&
            CheckRuleMatch(rule.CommandLineArgs, message.CommandLineArgs) &&
            CheckRuleMatch(rule.ExceptionType, message.ExceptionType) &&
            CheckRuleMatch(rule.ExceptionMessage, message.ExceptionMessage) &&
            CheckRuleMatch(rule.StackTrace, message.StackTrace);
 }
        /// <summary>
        /// Handle a MessageRoutingSystemError message
        /// </summary>
        /// <param name="message"></param>
        public void HandleMessage(MessageRoutingSystemError message)
        {
            PrintError(message);
            // Add the message to the database
            var messageId = _messageService.AddMessage(message.ApplicationName,
                                                      message.MachineName,
                                                      message.HelpText,
                                                      message.CommandLineArgs,
                                                      message.ExceptionType,
                                                      message.ExceptionMessage,
                                                      message.StackTrace,
                                                      message.InsertDate);

            var rules = _ruleService.GetRules().OrderBy(x => x.Order);
            bool messageMatchedToRule = false;

            foreach (var rule in rules)
            {
                var deliver = true;

                if (!IsMatch(rule, message)) continue;

                messageMatchedToRule = true;

                // check if rule is supposed to pool
                var isPool = rule.PoolMaxMessages != 0 || rule.PoolActiveTime != TimeSpan.Zero;
                if (isPool)
                {
                    deliver = PoolMessage(rule, messageId);
                }

                if (deliver)
                {
                    var emailer = new EmailClient(rule.Action, rule.CustomSubject);
                    var mailPriority = MailPriority.Normal;
                    if (rule.PriorityId != null)
                    {
                        var priority = _priorityService.GetPriorityById(rule.PriorityId.Value);
                        switch (priority.Name)
                        {
                            case "High":
                                mailPriority = MailPriority.High;
                                break;
                            case "Low":
                                mailPriority = MailPriority.Low;
                                break;
                            default:
                                mailPriority = MailPriority.Normal;
                                break;
                        }
                    }

                    emailer.Send(message, isPool, mailPriority);
                }

                // stop trying to match rules if continue processing is false
                if (!rule.ContinueProcessing)
                    break;
            }

            if (!messageMatchedToRule)
                DefaultDelivery(message);
        }
 public void Publish(MessageRoutingSystemError message)
 {
     _bus.Publish(message);
 }