public async Task <IActionResult> Post([FromBody] NewMessageViewModel message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Get the current user
// var user = await GetCurrentUserAsync();
// Create a new message to save to the database
var newMessage = new Message()
{
Content = message.Content,
//UserId = user.Id,
//User = user
UserName = message.UserName
};
var record = await _chatService.SaveMessage(newMessage);
// Call the client method 'addChatMessage' on all clients in the "MainChatroom" group.
this.Clients.Group(message.Group).AddChatMessage(new MessageViewModel(record));
return(new NoContentResult());
}
public ActionResult SendMessage(NewMessageViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var newMessage = new Message {
Content = model.Content,
DateSent = DateTime.Now,
SenderId = User.Identity.GetUserId()
};
if (model.ReplyId != Guid.Empty)
{
var parentMessage = db.Messages.Find(model.ReplyId);
parentMessage?.Replies.Add(newMessage);
db.Entry(parentMessage).State = EntityState.Modified;
}
else
{
db.Messages.Add(newMessage);
var discussion = db.Discussions.Find(model.DiscussionId);
discussion?.Messages.Add(newMessage);
db.Entry(discussion).State = EntityState.Modified;
}
db.SaveChanges();
TempData["Active"] = model.DiscussionId;
return(RedirectToAction("Discussion", new { id = model.CId }));
}
public ActionResult MessageNew(int?id)
{
if (id == null)
{
return(RedirectToAction("LoginIndex"));
}
if (Session["UserModel"] == null && !Request.IsAuthenticated)
{
return(RedirectToAction("LoginIndex"));
}
NewMessageViewModel messageVM = new NewMessageViewModel();
UserModel currentUser = (UserModel)Session["UserModel"];
var updateMessagesUnread = db.UserMessages.Where(e => e.IsUnread == true && e.UserId == currentUser.Id && e.Message.ToUserID == currentUser.Id).ToList();
updateMessagesUnread.ForEach(a => a.IsUnread = false);
db.SaveChanges();
messageVM.FromUserModel = currentUser;
messageVM.ToUserModel = db.UserModels.Find(id);
var msg = db.MessageModels.Where(mm => (mm.FromUserId == currentUser.Id && mm.ToUserID == id) || (mm.FromUserId == id && mm.ToUserID == currentUser.Id)).Take(40);
messageVM.Messages = msg.OrderBy(d => d.Created).ToList();
return(View(messageVM));
}
public ActionResult NewMessage()
{
var model = new NewMessageViewModel();
model.SessionId = Session.SessionID;
return(View("NewMessage", model));
}
public async Task <IActionResult> Post([FromBody] NewMessageViewModel message)
{
if (ModelState.IsValid)
{
// Get the current user
var user = await GetCurrentUserAsync();
if (user == null)
{
return(Forbid());
}
// Create a new message to save to the database
Message newMessage = new Message()
{
Content = message.Content,
UserId = user.Id,
User = user
};
// Save the new message
await _context.AddAsync(newMessage);
await _context.SaveChangesAsync();
MessageViewModel model = new MessageViewModel(newMessage);
// Call the client method 'addChatMessage' on all clients in the
// "MainChatroom" group.
this.Clients.Group("MainChatroom").AddChatMessage(model);
return(new NoContentResult());
}
return(BadRequest(ModelState));
}
public async Task <ActionResult> Compose(NewMessageViewModel message)
{
//ViewBag.PmView = "compose";
//ViewBag.Title = "Compose";
//set this incase invalid submittal
var userData = UserData;
message.RequireCaptcha = userData.Information.CommentPoints.Sum < VoatSettings.Instance.MinimumCommentPointsForCaptchaMessaging && VoatSettings.Instance.CaptchaEnabled;
if (!ModelState.IsValid)
{
return(View(message));
}
if (message.Recipient == null || message.Subject == null || message.Body == null)
{
return(RedirectToAction("Sent", "Messages"));
}
if (message.RequireCaptcha)
{
bool isCaptchaValid = await ReCaptchaUtility.Validate(Request);
if (!isCaptchaValid)
{
ModelState.AddModelError(string.Empty, "Incorrect recaptcha answer.");
return(View(message));
}
}
var sendMessage = new SendMessage()
{
Recipient = message.Recipient,
Message = message.Body,
Subject = message.Subject,
Sender = message.Sender
};
var cmd = new SendMessageCommand(sendMessage, false, true).SetUserContext(User);
var response = await cmd.Execute();
if (response.Success)
{
var m = response.Response;
if (m.SenderType == IdentityType.Subverse)
{
return(RedirectToAction("SubverseIndex", "Messages", new { subverse = m.Sender, type = MessageTypeFlag.Sent, state = MessageState.All }));
}
else
{
return(RedirectToAction("Sent", "Messages"));
}
}
else
{
ModelState.AddModelError(string.Empty, response.Message);
return(View(message));
}
}
public ActionResult Compose()
{
ViewBag.PmView = "compose";
ViewBag.Title = "Compose";
var recipient = Request.Params["recipient"];
var subject = Request.Params["subject"];
var subverse = (string)RouteData.Values["subverse"];
var model = new NewMessageViewModel()
{
Recipient = recipient, Subject = subject
};
var userData = UserData;
model.RequireCaptcha = userData.Information.CommentPoints.Sum < Settings.MinimumCommentPointsForCaptchaMessaging && !Settings.CaptchaDisabled;
if (!string.IsNullOrEmpty(subverse))
{
if (!ModeratorPermission.HasPermission(User.Identity.Name, subverse, ModeratorAction.SendMail))
{
return(RedirectToAction("Home", "Index"));
}
ViewBag.PmView = "mod";
model.Sender = UserDefinition.Format(subverse, IdentityType.Subverse);
}
// return compose view
return(View(model));
}
public ActionResult Create(NewMessageViewModel m)
{
if (ModelState.IsValid)
{
var conversation = convoSvc.SendMessage(m.ForID, m.Content);
}
return(RedirectToAction("Index"));
}
public async Task New(int dialogId, NewMessageViewModel newMessageModel)
{
var newMessageData = new NewMessageDTO {
UserId = User.Identity.GetUserId(),
DialogId = dialogId,
Body = newMessageModel.Body
};
await messageService.Create(newMessageData);
}
public async Task Send(NewMessageViewModel message)
{
var sender = _chatUsersRepository.FindByPrincipal(User);
await _sendMessage.Run(new ChatMessage
{
Contents = message.Contents,
DateCreated = DateTime.Now,
Destination = message.Destination,
Sender = sender
});
}
public MainWindow(IWebCommunicatorAsync <Message> communicator, IMessageDataRepository dataRepository)
{
InitializeComponent();
_MessagesVM = new MessagesViewModel(communicator, dataRepository);
_NewMessageVM = new NewMessageViewModel(communicator, dataRepository);
_MessagesVM.Notification += ShowPopup;
_NewMessageVM.Notification += ShowPopup;
this.MessagesControl.DataContext = _MessagesVM;
this.NewMessageControl.DataContext = _NewMessageVM;
}
public ActionResult ReplySend(NewMessageViewModel m)
{
var pc = pcSvc.GetPartnerCallById(m.ForID);
if (ModelState.IsValid && pc != null)
{
new ConversationService().PrivatePartnerCallReply(pc, m.Content);
return(Json(new { Success = true }));
}
else
{
return(Json(new { Success = false }));
}
}
public ActionResult Append(NewMessageViewModel m)
{
if (ModelState.IsValid)
{
var conversation = convoSvc.GetConversationById(m.ForID);
var otherPartyID = conversation.PartyAID;
if (CfIdentity.UserID == otherPartyID)
{
otherPartyID = conversation.PartyBID;
}
convoSvc.SendMessage(otherPartyID, m.Content);
}
return(RedirectToAction("Index"));
}
public void SendMessage(NewMessageViewModel message)
{
var messageToDb = new Message()
{
Topic = message.Topic,
Content = message.Content,
SenderUserId = message.SenderId,
ReceiverUserId = message.ReceiverId,
SendingDate = DateTime.Now
};
_db.Messages.Add(messageToDb);
_db.SaveChanges();
}
public void SendNewMessage(string username, NewMessageViewModel message)
{
var fromUser = this.dbContext.Users.First(u => u.UserName == username);
var toUser = this.dbContext.Users.First(u => u.UserName == message.ToUser);
var newMessage = new Message()
{
Id = Guid.NewGuid(),
FromUser = fromUser,
ToUser = toUser,
Content = message.Content,
SendOn = DateTime.Now
};
this.dbContext.Messages.Add(newMessage);
this.dbContext.SaveChanges();
}
public async Task <ActionResult> SendMessage(NewMessageViewModel newMessage)
{
if (ModelState.IsValid)
{
var patient = await _db.Patients.FindAsync(newMessage.PatientId);
if (patient != null)
{
var messageNotification = new MessageNotification()
{
SendDateTime = DateTime.Now,
MessageBody = newMessage.MessageBody,
PatientId = newMessage.PatientId,
LiaisonId = patient.LiaisonId
};
_db.MessageNotifications.Add(messageNotification);
await _db.SaveChangesAsync();
var body = "Hello " + patient.Liaison.FirstName + ",<br /><br />" +
"Following is a new message from your CCM Patient:<br /> " +
"Name: " + patient.FirstName + " " + patient.LastName + "<br />" +
"Cell Phone Number: " + patient.MobilePhoneNumber + "<br />" +
"Home Phone Number: " + patient.HomePhoneNumber + "<br />" +
"CCM Enrollment Status: " + patient.EnrollmentStatus + "<br />" +
"CCM Status: " + patient.CcmStatus + "<br /><br>" +
newMessage.MessageBody + "<br /><br />" +
"<small>This email is system generated and is not monitored. Please, do not reply to this email.</small>";
var ems = new EmailService();
await ems.SendAsync(new IdentityMessage
{
Destination = patient.Liaison.Email,
Subject = "New message from CCM patient " + patient.FirstName + " " + patient.LastName,
Body = body
});
}
}
return(RedirectToAction("Details", "PatientPortal", new { patientId = newMessage.PatientId }));
}
public async Task Send(int dialogId, NewMessageViewModel message)
{
var newMessageData = new NewMessageDTO {
UserId = Context.User.Identity.GetUserId(),
DialogId = dialogId,
Body = message.Body
};
var createdMessageData = await messageService.Create(newMessageData);
Mapper.Initialize(cfg => cfg.CreateMap <MessageDTO, MessageViewModel>()
.ForMember("AuthorAvatarUrl", opt => opt.MapFrom(m => $"/avatars/{m.AuthorId}"))
);
var createdMessage = Mapper.Map <MessageViewModel>(createdMessageData);
Clients.Group(dialogId.ToString()).addMessage(createdMessage);
}
public ActionResult NewMessage(string username, NewMessageViewModel model)
{
if (!ModelState.IsValid)
{
return(View("NewMessage", model));
}
var message = new Message
{
IsPrivate = model.IsPrivate,
MessageText = model.MessageText,
Sender = base.CurrentUser,
Recipient = model.Recipient,
};
messageDal.CreateMessage(message);
return(RedirectToAction("Dashboard", "Messages", new { username = base.CurrentUser }));
}
public ActionResult NewMessagePartial(NewMessageViewModel model)
{
if (ModelState.IsValid)
{
try
{
var toUser = UserRepository.Get(model.Email);
var messageRepository = DependencyResolver.Current.GetService <IMessageRepository>();
messageRepository.SentMessage(CurrentUser, toUser, model.MsgText, model.Title);
return(RedirectToAction("Messages", "User", new { @act = "outbox", @success = 1 }));
}
catch (Exception)
{
ModelState.AddModelError("", Resources.SomethingWrong);
}
}
return(View(model));
}
private async Task ReadLatestReceivers(NewMessageViewModel viewModel, CancellationToken cancellationToken)
{
var sender = await AccountProvider.GetAccountForCurrentUser(cancellationToken);
var lastReceivers = await MailAppDbContext.Messages
.Include(x => x.MessagePersons)
.ThenInclude(x => x.Account)
.Include(x => x.MessagePersons)
.ThenInclude(x => x.Type)
.Where(x => x.MessagePersons.Any(y => y.Type != MessagePersonType.Sender && y.Account == sender))
.OrderByDescending(x => x.SentDate)
.Distinct()
.Take(5)
.ToArrayAsync(cancellationToken);
viewModel.LastReceivers = lastReceivers
.SelectMany(x => x.Receivers)
.Distinct()
.Select(x => new AccountViewModel(x))
.ToArray();
}
public ActionResult Compose()
{
//CORE_PORT: Ported correctly?
//var recipient = Request.Params["recipient"];
//var subject = Request.Params["subject"];
var recipient = Request.Query["recipient"].FirstOrDefault();
var subject = Request.Query["subject"].FirstOrDefault();
var subverse = (string)RouteData.Values["subverse"];
var model = new NewMessageViewModel()
{
Recipient = recipient, Subject = subject
};
var userData = UserData;
model.RequireCaptcha = userData.Information.CommentPoints.Sum < VoatSettings.Instance.MinimumCommentPointsForCaptchaMessaging && VoatSettings.Instance.CaptchaEnabled;
if (!string.IsNullOrEmpty(subverse))
{
if (!ModeratorPermission.HasPermission(User, subverse, ModeratorAction.SendMail))
{
return(RedirectToAction("Home", "Index"));
}
ViewBag.PmView = "mod";
model.Sender = UserDefinition.Format(subverse, IdentityType.Subverse);
SetMenuNavigationModel("Compose", MenuType.Smail, subverse);
}
else
{
SetMenuNavigationModel("Compose", MenuType.UserMessages);
}
// return compose view
return(View(model));
}
public async Task <MessageViewModel> Create([FromBody] NewMessageViewModel newMessage)
{
MessageViewModel result = null;
try
{
if (ModelState.IsValid)
{
var message = _mapper.Map <Message>(newMessage);
message.UserId = _userManager.GetUserId(User);
message.Date = DateTime.Now;
message = await _unitOfWork.Messages.AddAsync(message);
result = _mapper.Map <MessageViewModel>(message);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error when adding message");
}
return(result);
}
public ActionResult ReplySend(NewMessageViewModel m)
{
var pc = pcSvc.GetPartnerCallById(m.ForID);
if (ModelState.IsValid && pc != null)
{
new ConversationService().PrivatePartnerCallReply(pc, m.Content);
return Json(new { Success = true });
}
else
{
return Json(new { Success = false });
}
}
public ActionResult NewMessage()
{
var model = new NewMessageViewModel();
return(View("NewMessage", model));
}
public async Task <IActionResult> GetNewMessage(NewMessageViewModel viewModel, CancellationToken cancellationToken)
{
await ReadLatestReceivers(viewModel, cancellationToken);
return(View("NewMessage", viewModel));
}
public async Task <IActionResult> NewMessage(NewMessageViewModel request, CancellationToken cancellationToken)
{
await ReadLatestReceivers(request, cancellationToken);
if (!ModelState.IsValid)
{
return(View(request));
}
if (string.IsNullOrEmpty(request.Receiver) && string.IsNullOrEmpty(request.Cc) && string.IsNullOrEmpty(request.Bcc))
{
ModelState.AddModelError(nameof(request.Receiver), "There is no receiver.");
return(View(request));
}
if (string.IsNullOrEmpty(request.Subject) && string.IsNullOrEmpty(request.Text))
{
ModelState.AddModelError(nameof(request.Subject), "Message should have subject or text");
return(View(request));
}
var message = new Message
{
Subject = request.Subject,
Text = request.Text,
SentDate = DateTime.Now,
Notification = request.Notification,
};
var sender = await AccountProvider.GetAccountForCurrentUser(cancellationToken);
foreach (var i in request.FileForm ?? new IFormFile[0])
{
var fileName = i.FileName;
var contentType = i.ContentType;
var blobId = Guid.NewGuid().ToString();
message.AddAttachments(new MessageAttachment(blobId, fileName, contentType));
var blobClient = ContainerClient.GetBlobClient(blobId);
await blobClient.UploadAsync(i.OpenReadStream(), true, cancellationToken);
}
if (sender == null)
{
return(BadRequest());
}
message.SetSender(sender);
var flag = true;
async Task SetPersons(String addresses, Action <Account> f1, Action <Group> f2)
{
foreach (var address in (addresses ?? String.Empty).Split(";", StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim()).ToArray())
{
var group = await MailAppDbContext.Groups.Include(x => x.GroupAccounts).ThenInclude(x => x.Account).SingleOrDefaultAsync(x => x.Name == address, cancellationToken);
if (group != null)
{
f2(group);
}
else
{
var account = await MailAppDbContext.Accounts.SingleOrDefaultAsync(x => x.Email == address, cancellationToken);
if (account != null)
{
f1(account);
}
else
{
flag = false;
}
}
}
}
await SetPersons(request.Receiver, account => message.AddReceiver(account), group => message.AddReceiver(group));
if (flag == false)
{
ModelState.AddModelError(nameof(request.Receiver), "Invadlid mail or group name");
return(View(request));
}
await SetPersons(request.Cc, account => message.AddCc(account), group => message.AddCc(group));
if (flag == false)
{
ModelState.AddModelError(nameof(request.Cc), "Invadlid mail or group name");
return(View(request));
}
await SetPersons(request.Bcc, account => message.AddReceiver(account), group => message.AddBcc(group));
if (flag == false)
{
ModelState.AddModelError(nameof(request.Bcc), "Invadlid mail or group name");
return(View(request));
}
MailAppDbContext.Messages.Add(message);
await MailAppDbContext.SaveChangesAsync(cancellationToken);
TelemetryClient.TrackEvent("Message sent");
return(RedirectToAction(nameof(Index)));
}
public IHttpActionResult SendMessage(NewMessageViewModel message)
{
_service.SendMessage(message);
return(Ok());
}
public ActionResult NewMessage(NewMessageViewModel message)
{
this.messageService.SendNewMessage(this.User.Identity.Name, message);
return(this.RedirectToAction("Inbox"));
}
public ActionResult NewMessage()
{
var messageVm = new NewMessageViewModel();
return(this.View(messageVm));
}
public NewMessageView()
{
InitializeComponent();
_viewModel = new NewMessageViewModel();
DataContext = _viewModel;
}
public NewMessage()
{
InitializeComponent();
BindingContext = viewModel = new NewMessageViewModel();
}
