public ActionResult Create(CreatePrivateMessageViewModel createPrivateMessageViewModel)
        {
            var settings = SettingsService.GetSettings();

            if (!settings.EnablePrivateMessages || LoggedOnReadOnlyUser.DisablePrivateMessages == true)
            {
                throw new Exception(LocalizationService.GetResourceString("Errors.GenericMessage"));
            }
            using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
            {
                if (ModelState.IsValid)
                {
                    var loggedOnUser = MembershipService.GetUser(LoggedOnReadOnlyUser.Id);
                    var memberTo     = MembershipService.GetUser(createPrivateMessageViewModel.To);

                    // Check the user they are trying to message hasn't blocked them
                    if (loggedOnUser.BlockedByOtherUsers.Any(x => x.Blocker.Id == memberTo.Id))
                    {
                        return(Content(PmAjaxError(LocalizationService.GetResourceString("PM.BlockedMessage"))));
                    }

                    // Check flood control
                    var lastMessage = _privateMessageService.GetLastSentPrivateMessage(LoggedOnReadOnlyUser.Id);
                    // If this message they are sending now, is to the same person then ignore flood control
                    if (lastMessage != null && createPrivateMessageViewModel.To != lastMessage.UserTo.Id)
                    {
                        if (DateUtils.TimeDifferenceInSeconds(DateTime.UtcNow, lastMessage.DateSent) < settings.PrivateMessageFloodControl)
                        {
                            return(Content(PmAjaxError(LocalizationService.GetResourceString("PM.SendingToQuickly"))));
                        }
                    }

                    // first check they are not trying to message themself!
                    if (memberTo != null)
                    {
                        // Map the view model to message
                        var privateMessage = new PrivateMessage
                        {
                            UserFrom = loggedOnUser,
                            Message  = createPrivateMessageViewModel.Message,
                        };

                        // Check settings
                        if (settings.EnableEmoticons == true)
                        {
                            privateMessage.Message = _configService.Emotify(privateMessage.Message);
                        }

                        // check the member
                        if (!String.Equals(memberTo.UserName, LoggedOnReadOnlyUser.UserName, StringComparison.CurrentCultureIgnoreCase))
                        {
                            // Check in box size for both
                            var receiverCount = _privateMessageService.GetAllReceivedByUser(memberTo.Id).Count;
                            if (receiverCount > settings.MaxPrivateMessagesPerMember)
                            {
                                return(Content(string.Format(LocalizationService.GetResourceString("PM.ReceivedItemsOverCapcity"), memberTo.UserName)));
                            }

                            // If the receiver is about to go over the allowance them let then know too
                            if (receiverCount > (settings.MaxPrivateMessagesPerMember - SiteConstants.Instance.PrivateMessageWarningAmountLessThanAllowedSize))
                            {
                                // Send user a warning they are about to exceed
                                var sb = new StringBuilder();
                                sb.Append($"<p>{LocalizationService.GetResourceString("PM.AboutToExceedInboxSizeBody")}</p>");
                                var email = new Email
                                {
                                    EmailTo = memberTo.Email,
                                    NameTo  = memberTo.UserName,
                                    Subject = LocalizationService.GetResourceString("PM.AboutToExceedInboxSizeSubject")
                                };
                                email.Body = _emailService.EmailTemplate(email.NameTo, sb.ToString());
                                _emailService.SendMail(email);
                            }

                            // Good to go send the message!
                            privateMessage.UserTo = memberTo;
                            _privateMessageService.Add(privateMessage);

                            try
                            {
                                // Finally send an email to the user so they know they have a new private message
                                // As long as they have not had notifications disabled
                                if (memberTo.DisableEmailNotifications != true)
                                {
                                    var email = new Email
                                    {
                                        EmailTo = memberTo.Email,
                                        Subject = LocalizationService.GetResourceString("PM.NewPrivateMessageSubject"),
                                        NameTo  = memberTo.UserName
                                    };

                                    var sb = new StringBuilder();
                                    sb.Append($"<p>{string.Format(LocalizationService.GetResourceString("PM.NewPrivateMessageBody"), LoggedOnReadOnlyUser.UserName)}</p>");
                                    sb.Append(AppHelpers.ConvertPostContent(createPrivateMessageViewModel.Message));
                                    email.Body = _emailService.EmailTemplate(email.NameTo, sb.ToString());
                                    _emailService.SendMail(email);
                                }

                                unitOfWork.Commit();

                                return(PartialView("_PrivateMessage", privateMessage));
                            }
                            catch (Exception ex)
                            {
                                unitOfWork.Rollback();
                                LoggingService.Error(ex);
                                return(Content(PmAjaxError(LocalizationService.GetResourceString("Errors.GenericMessage"))));
                            }
                        }
                        else
                        {
                            return(Content(PmAjaxError(LocalizationService.GetResourceString("PM.TalkToSelf"))));
                        }
                    }
                    else
                    {
                        // Error send back to user
                        return(Content(PmAjaxError(LocalizationService.GetResourceString("PM.UnableFindMember"))));
                    }
                }
                return(Content(PmAjaxError(LocalizationService.GetResourceString("Errors.GenericMessage"))));
            }
        }
        public ActionResult Create(CreatePrivateMessageViewModel createPrivateMessageViewModel)
        {
            if (!SettingsService.GetSettings().EnablePrivateMessages || LoggedOnUser.DisablePrivateMessages == true)
            {
                return(ErrorToHomePage(LocalizationService.GetResourceString("Errors.GenericMessage")));
            }
            using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
            {
                if (ModelState.IsValid)
                {
                    var userTo = createPrivateMessageViewModel.UserToUsername;

                    // first check they are not trying to message themself!
                    if (userTo.ToLower() != LoggedOnUser.UserName.ToLower())
                    {
                        // Map the view model to message
                        var privateMessage = new PrivateMessage
                        {
                            UserFrom = LoggedOnUser,
                            Subject  = createPrivateMessageViewModel.Subject,
                            Message  = createPrivateMessageViewModel.Message,
                        };
                        // now get the user its being sent to
                        var memberTo = MembershipService.GetUser(userTo);

                        // check the member
                        if (memberTo != null)
                        {
                            // Check in box size for both

                            var receiverCount = _privateMessageService.GetAllReceivedByUser(memberTo.Id).Count;
                            if (receiverCount > SettingsService.GetSettings().MaxPrivateMessagesPerMember)
                            {
                                ModelState.AddModelError(string.Empty, string.Format(LocalizationService.GetResourceString("PM.ReceivedItemsOverCapcity"), memberTo.UserName));
                            }
                            else
                            {
                                // If the receiver is about to go over the allowance them let then know too
                                if (receiverCount > (SettingsService.GetSettings().MaxPrivateMessagesPerMember - SiteConstants.PrivateMessageWarningAmountLessThanAllowedSize))
                                {
                                    // Send user a warning they are about to exceed
                                    var sb = new StringBuilder();
                                    sb.AppendFormat("<p>{0}</p>", LocalizationService.GetResourceString("PM.AboutToExceedInboxSizeBody"));
                                    var email = new Email
                                    {
                                        EmailFrom = SettingsService.GetSettings().AdminEmailAddress,
                                        EmailTo   = memberTo.Email,
                                        NameTo    = memberTo.UserName,
                                        Subject   = LocalizationService.GetResourceString("PM.AboutToExceedInboxSizeSubject")
                                    };
                                    email.Body = _emailService.EmailTemplate(email.NameTo, sb.ToString());
                                    _emailService.SendMail(email);
                                }

                                // Good to go send the message!
                                privateMessage.UserTo = memberTo;
                                _privateMessageService.Add(privateMessage);

                                try
                                {
                                    TempData[AppConstants.MessageViewBagName] = new GenericMessageViewModel
                                    {
                                        Message     = LocalizationService.GetResourceString("PM.MessageSent"),
                                        MessageType = GenericMessages.success
                                    };

                                    unitOfWork.Commit();

                                    // Finally send an email to the user so they know they have a new private message
                                    // As long as they have not had notifications disabled
                                    if (memberTo.DisableEmailNotifications != true)
                                    {
                                        var email = new Email
                                        {
                                            EmailFrom = SettingsService.GetSettings().NotificationReplyEmail,
                                            EmailTo   = memberTo.Email,
                                            Subject   = LocalizationService.GetResourceString("PM.NewPrivateMessageSubject"),
                                            NameTo    = memberTo.UserName
                                        };

                                        var sb = new StringBuilder();
                                        sb.AppendFormat("<p>{0}</p>", string.Format(LocalizationService.GetResourceString("PM.NewPrivateMessageBody"), LoggedOnUser.UserName));
                                        email.Body = _emailService.EmailTemplate(email.NameTo, sb.ToString());
                                        _emailService.SendMail(email);
                                    }

                                    return(RedirectToAction("Index"));
                                }
                                catch (Exception ex)
                                {
                                    unitOfWork.Rollback();
                                    LoggingService.Error(ex);
                                    ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("Errors.GenericMessage"));
                                }
                            }
                        }
                        else
                        {
                            // Error send back to user
                            ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("PM.UnableFindMember"));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError(string.Empty, LocalizationService.GetResourceString("PM.TalkToSelf"));
                    }
                }
                TempData[AppConstants.MessageViewBagName] = null;
                return(View(createPrivateMessageViewModel));
            }
        }