public ActionResult PrivateMessages(DialoguePage page)
{
if (CurrentMember.DisablePrivateMessages)
{
var message = new GenericMessageViewModel
{
Message = Lang("Errors.NoPermission"),
MessageType = GenericMessages.Danger
};
ShowMessage(message);
return(Redirect(Settings.ForumRootUrl));
}
using (UnitOfWorkManager.NewUnitOfWork())
{
var pageIndex = AppHelpers.ReturnCurrentPagingNo();
var pagedMessages = PrivateMessageService.GetPagedReceivedMessagesByUser(pageIndex, DialogueConfiguration.Instance.PrivateMessageListSize, CurrentMember);
var viewModel = new PageListPrivateMessageViewModel(page)
{
ListPrivateMessageViewModel = new ListPrivateMessageViewModel
{
Messages = pagedMessages,
PageIndex = pageIndex,
TotalCount = pagedMessages.TotalCount
},
PageTitle = Lang("PM.ReceivedPrivateMessages")
};
return(View(PathHelper.GetThemeViewPath("PrivateMessages"), viewModel));
}
}
public ActionResult Delete(DeletePrivateMessageViewModel deletePrivateMessageViewModel)
{
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
if (Request.IsAjaxRequest())
{
var privateMessage = PrivateMessageService.Get(deletePrivateMessageViewModel.Id);
if (privateMessage.MemberToId == CurrentMember.Id | privateMessage.MemberFromId == CurrentMember.Id)
{
PrivateMessageService.DeleteMessage(privateMessage);
}
else
{
throw new Exception(Lang("Errors.NoPermission"));
}
}
try
{
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
LogError(ex);
throw new Exception(Lang("Errors.GenericMessage"));
}
}
return(null);
}
private PrivateMessageService GetService()
{
_mockPMRepo = new Mock <IPrivateMessageRepository>();
_mockSettings = new Mock <ISettingsManager>();
_mockTextParse = new Mock <ITextParsingService>();
var service = new PrivateMessageService(_mockPMRepo.Object, _mockSettings.Object, _mockTextParse.Object);
return(service);
}
public void BeforeEachTest()
{
_botServiceMock = new Mock <IBotService>();
_withdrawalService = new Mock <IWithdrawalService>();
_walletUserRepositoryMock = new Mock <IWalletUserRepository>();
_settingsServiceMock = new Mock <ISettingsService>();
_botConfigurationMock = new BotConfiguration();
var botConfigurationOptions = Options.Create(_botConfigurationMock);
_sut = new PrivateMessageService(botConfigurationOptions, _botServiceMock.Object,
_walletUserRepositoryMock.Object, _withdrawalService.Object, _settingsServiceMock.Object);
}
public ActionResult ViewPrivateMessage(DialoguePage page)
{
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
var id = Request["id"];
if (string.IsNullOrEmpty(id))
{
return(ErrorToHomePage(Lang("Errors.GenericMessage")));
}
var message = PrivateMessageService.Get(new Guid(id));
if (message.MemberToId == CurrentMember.Id | message.MemberFromId == CurrentMember.Id)
{
//Mark as read if this is the receiver of the message
if (message.MemberToId == CurrentMember.Id)
{
// Update message as read
message.IsRead = true;
// Get the sent version and update that too
var sentMessage = PrivateMessageService.GetMatchingSentPrivateMessage(message.Subject, message.DateSent, message.MemberFromId, message.MemberToId);
if (sentMessage != null)
{
sentMessage.IsRead = true;
}
try
{
unitOfWork.Commit();
}
catch (Exception ex)
{
unitOfWork.Rollback();
LogError(ex);
}
}
var viewModel = new ViewPrivateMessageViewModel(page)
{
Message = message,
PageTitle = message.Subject
};
return(View(PathHelper.GetThemeViewPath("PrivateMessageView"), viewModel));
}
return(ErrorToHomePage(Lang("Errors.NoPermission")));
}
}
public ActionResult PrivateMessagesSent(DialoguePage page)
{
using (UnitOfWorkManager.NewUnitOfWork())
{
var pageIndex = AppHelpers.ReturnCurrentPagingNo();
var pagedMessages = PrivateMessageService.GetPagedSentMessagesByUser(pageIndex, DialogueConfiguration.Instance.PrivateMessageListSize, CurrentMember);
var viewModel = new PageListPrivateMessageViewModel(page)
{
ListPrivateMessageViewModel = new ListPrivateMessageViewModel
{
Messages = pagedMessages
},
PageTitle = Lang("PM.SentPrivateMessages")
};
return(View(PathHelper.GetThemeViewPath("PrivateMessagesSent"), viewModel));
}
}
public void CreateShouldCreateVote()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "CreateShouldCreateVote_DB")
.Options;
var dbContext = new ApplicationDbContext(options);
var privateMessageService = new PrivateMessageService(dbContext);
var pm = new PrivateMessage();
privateMessageService.Create(pm);
var pmTest = dbContext.PrivateMessages.ToList();
Assert.Single(pmTest);
}
private static void MemberServiceOnDeleting(IMemberService sender, DeleteEventArgs <IMember> deleteEventArgs)
{
var memberService = new Services.MemberService();
var unitOfWorkManager = new UnitOfWorkManager(ContextPerRequest.Db);
var uploadedFileService = new UploadedFileService();
var postService = new PostService();
var memberPointsService = new MemberPointsService();
var pollService = new PollService();
var topicService = new TopicService();
var topicNotificationService = new TopicNotificationService();
var activityService = new ActivityService();
var privateMessageService = new PrivateMessageService();
var badgeService = new BadgeService();
var voteService = new VoteService();
var categoryNotificationService = new CategoryNotificationService();
using (var unitOfWork = unitOfWorkManager.NewUnitOfWork())
{
try
{
foreach (var member in deleteEventArgs.DeletedEntities)
{
var canDelete = memberService.DeleteAllAssociatedMemberInfo(member.Id, unitOfWork, uploadedFileService, postService, memberPointsService, pollService, topicService,
topicNotificationService, activityService, privateMessageService, badgeService, voteService, categoryNotificationService);
if (!canDelete)
{
deleteEventArgs.Cancel = true;
//TODO - THIS DOESN'T WORK - JUST LOG IT
//var clientTool = new ClientTools((Page)HttpContext.Current.CurrentHandler);
//clientTool.ShowSpeechBubble(SpeechBubbleIcon.Error, "Error", "Unable to delete member. Check logfile for further information");
AppHelpers.LogError($"There was an error attemping to delete member {member.Name} and all of their associated data (Posts, Topics etc...)");
break;
}
}
}
catch (Exception ex)
{
AppHelpers.LogError("Error attempting to delete members", ex);
}
}
}
public PartialViewResult SideAdminPanel()
{
using (UnitOfWorkManager.NewUnitOfWork())
{
var count = 0;
if (CurrentMember != null)
{
count = PrivateMessageService.NewPrivateMessageCount(CurrentMember.Id);
}
if (count > 0)
{
ShowMessage(new GenericMessageViewModel
{
Message = Lang("Member.HasNewPrivateMessages"),
MessageType = GenericMessages.Info
});
}
return(PartialView(PathHelper.GetThemePartialViewPath("SideAdminPanel"),
new ViewAdminSidePanelViewModel {
CurrentUser = CurrentMember, NewPrivateMessageCount = count
}));
}
}
public ActionResult Create(CreatePrivateMessageViewModel createPrivateMessageViewModel)
{
if (!Settings.AllowPrivateMessages || CurrentMember.DisablePrivateMessages)
{
return(ErrorToHomePage(Lang("Errors.GenericMessage")));
}
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
if (ModelState.IsValid)
{
var userTo = createPrivateMessageViewModel.UserToUsername;
// first check they are not trying to message themself!
if (!string.Equals(userTo, CurrentMember.UserName, StringComparison.CurrentCultureIgnoreCase))
{
// Map the view model to message
var privateMessage = new PrivateMessage
{
MemberFrom = CurrentMember,
MemberFromId = CurrentMember.Id,
Subject = createPrivateMessageViewModel.Subject,
Message = createPrivateMessageViewModel.Message
};
// now get the user its being sent to
var memberTo = MemberService.Get(userTo);
// check the member
if (memberTo != null)
{
// Check in box size
// First check sender
var receiverCount = PrivateMessageService.GetAllReceivedByUser(memberTo.Id).Count;
if (receiverCount > Settings.PrivateMessageInboxSize)
{
ModelState.AddModelError(string.Empty, string.Format(Lang("PM.ReceivedItemsOverCapcity"), memberTo.UserName));
}
else
{
// Good to go send the message!
privateMessage.MemberTo = memberTo;
privateMessage.MemberToId = memberTo.Id;
PrivateMessageService.Add(privateMessage);
try
{
ShowMessage(new GenericMessageViewModel
{
Message = Lang("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 = Settings.NotificationReplyEmailAddress,
EmailTo = memberTo.Email,
Subject = Lang("PM.NewPrivateMessageSubject"),
NameTo = memberTo.UserName
};
var sb = new StringBuilder();
sb.AppendFormat("<p>{0}</p>", string.Format(Lang("PM.NewPrivateMessageBody"), CurrentMember.UserName));
email.Body = EmailService.EmailTemplate(email.NameTo, sb.ToString());
EmailService.SendMail(email);
}
return(Redirect(Urls.GenerateUrl(Urls.UrlType.MessageInbox)));
}
catch (Exception ex)
{
unitOfWork.Rollback();
LogError(ex);
ModelState.AddModelError(string.Empty, Lang("Errors.GenericMessage"));
}
}
}
else
{
// Error send back to user
ModelState.AddModelError(string.Empty, Lang("PM.UnableFindMember"));
}
}
else
{
ModelState.AddModelError(string.Empty, Lang("PM.TalkToSelf"));
}
}
ShowMessage();
return(Redirect(Urls.GenerateUrl(Urls.UrlType.MessageCreate)));
}
}
public ActionResult PrivateMessagesCreate(DialoguePage page)
{
var to = Request["to"];
var id = Request["id"];
// Check if private messages are enabled
if (!Settings.AllowPrivateMessages || CurrentMember.DisablePrivateMessages)
{
return(ErrorToHomePage(Lang("Errors.GenericMessage")));
}
// Check flood control
var lastMessage = PrivateMessageService.GetLastSentPrivateMessage(CurrentMember.Id);
if (lastMessage != null && AppHelpers.TimeDifferenceInMinutes(DateTime.UtcNow, lastMessage.DateSent) < Settings.PrivateMessageFloodControl)
{
ShowMessage(new GenericMessageViewModel
{
Message = Lang("PM.SendingToQuickly"),
MessageType = GenericMessages.Danger
});
return(Redirect(Urls.GenerateUrl(Urls.UrlType.MessageInbox)));
}
// Check outbox size
var senderCount = PrivateMessageService.GetAllSentByUser(CurrentMember.Id).Count;
if (senderCount > Settings.PrivateMessageInboxSize)
{
ShowMessage(new GenericMessageViewModel
{
Message = Lang("PM.SentItemsOverCapcity"),
MessageType = GenericMessages.Danger
});
return(Redirect(Urls.GenerateUrl(Urls.UrlType.MessageInbox)));
}
var viewModel = new PageCreatePrivateMessageViewModel(page)
{
CreatePrivateMessageViewModel = new CreatePrivateMessageViewModel(),
PageTitle = Lang("PM.CreatePrivateMessage")
};
// add the username to the to box if available
if (to != null)
{
var userTo = MemberService.Get(Convert.ToInt32(to));
viewModel.CreatePrivateMessageViewModel.UserToUsername = userTo.UserName;
}
// See if this is a reply or not
if (id != null)
{
var previousMessage = PrivateMessageService.Get(new Guid(id));
// Its a reply, get the details
viewModel.CreatePrivateMessageViewModel.UserToUsername = previousMessage.MemberFrom.UserName;
viewModel.CreatePrivateMessageViewModel.Subject = previousMessage.Subject;
viewModel.CreatePrivateMessageViewModel.PreviousMessage = previousMessage.Message;
}
return(View(PathHelper.GetThemeViewPath("PrivateMessagesCreate"), viewModel));
}
public PrivateMessageController(PrivateMessageService privateMessageService)
{
_privateMessageService = privateMessageService;
}
