public static Message AddUserMessage(string userId, int chatId, MessageBindingModel model)
{
Chat chat = context.Chats.FirstOrDefault(c => c.ChatId == chatId);
if (chat == null)
{
throw new NullReferenceException();
}
UserChat uchat = context.UserChats.FirstOrDefault(u =>
u.UserId.Equals(userId) && u.ChatId.Equals(chatId));
if (!uchat.UserId.Equals(userId))
{
throw new UnauthorizedAccessException();
}
var message = new Message
{
ChatId = chatId,
SentDate = DateTime.Now,
Text = model.Text,
UserId = userId
};
context.Messages.Add(message);
context.SaveChanges();
return(message);
}
public ActionResult PostMessage(MessageBindingModel m)
{
var userId = User.Identity.GetUserId();
if (!ModelState.IsValid)
{
return RedirectToAction("UserMessages", "Messages");
}
if (!Data.Users.Any(u => u.UserName == m.UserName))
{
return RedirectToAction("UserMessages", "Messages");
}
Data.Messages.Add(new Message
{
ReceiverId = Data.Users
.FirstOrDefault(u => u.UserName == m.UserName).Id,
SenderId = userId,
Text = m.Text,
SentOn = DateTime.Now
});
Data.SaveChanges();
return RedirectToAction("UserMessages", "Messages");
}
public async Task <IActionResult> SaveMessage([FromBody] MessageBindingModel model)
{
Result result;
if (!ModelState.IsValid)
{
result = new Result
{
IsSuccess = false,
EntityId = Guid.Empty,
Error = "Ошибка в заполненной форме"
};
return(BadRequest(JsonConvert.SerializeObject(result, Formatting.None, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
})));
}
var messageDto = new MessageDto
{
Description = model.Message,
CustomerId = model.CurrentCustomerId,
CompanionId = model.OfferOwnerId,
Subject = (await _offerService.Get(model.OfferId)).Title
};
result = await _messageService.SaveMessage(messageDto);
return(Ok(JsonConvert.SerializeObject(result, Formatting.None, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
})));
}
public ActionResult PostMessage(MessageBindingModel m)
{
var userId = this.User.Identity.GetUserId();
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("UserMessages", "Messages"));
}
if (!this.Data.Users.Any(u => u.UserName == m.UserName))
{
return(this.RedirectToAction("UserMessages", "Messages"));
}
this.Data.Messages.Add(new Message
{
ReceiverId = this.Data.Users
.FirstOrDefault(u => u.UserName == m.UserName).Id,
SenderId = userId,
Text = m.Text,
SentOn = DateTime.Now
});
this.Data.SaveChanges();
return(this.RedirectToAction("UserMessages", "Messages"));
}
public void Insert(MessageBindingModel model)
{
using (var context = new ForumDatabase())
{
context.Message.Add(CreateModel(model, new Message()));
context.SaveChanges();
}
}
private Message CreateModel(MessageBindingModel model, Message message)
{
message.Text = model.Text;
message.Time = model.Time;
message.Topicname = model.NameTopic;
message.Visitorlogin = model.LoginUser;
return(message);
}
public async Task <IHttpActionResult> UpdateMessage(MessageBindingModel model)
{
var db = IlevusDBContext.Create();
if (!await db.UpdateSystemMessage(model))
{
return(BadRequest("Something happenned..."));
}
return(Ok("Message updated successfully."));
}
public Message SendMessage(MessageBindingModel message)
{
if (!message.SenderId.HasValue || !message.ReceiverId.HasValue || message.Content == null)
{
throw new CustomException("Errors.INVALID_INPUT", "Errors.INVALID_INPUT");
}
Message _message = MessageAdapter.ToModel(message);
Create(_message);
return(_message);
}
public IViewComponentResult Invoke(string receiverId, string senderId, string conversationId)
{
var inputModel = new MessageBindingModel
{
SenderId = senderId,
ReceiverId = receiverId,
ConversationId = conversationId
};
return(View(inputModel));
}
public void CreateOrUpdate(MessageBindingModel model)
{
if (model.Id.HasValue)
{
messageStorage.Update(model);
}
else
{
messageStorage.Insert(model);
}
}
public void AddMessage(MessageBindingModel model)
{
Message message = new Message()
{
Sender = model.Email,
Subject = model.Subject,
Content = model.Message
};
this.context.Messages.Add(message);
this.context.SaveChanges();
}
public IActionResult Contacts(MessageBindingModel model, HttpResponse response)
{
if (string.IsNullOrEmpty(model.Email) || string.IsNullOrEmpty(model.Subject))
{
Redirect(response, "/home/contacts");
}
MessageService service = new MessageService(Data.Data.Context);
service.AddMessage(model);
Redirect(response, "home/index");
return(null);
}
public void Delete(MessageBindingModel model)
{
var element = messageStorage.GetElement(new MessageBindingModel {
Id = model.Id
});
if (element == null)
{
throw new Exception("Элемент не найден");
}
messageStorage.Delete(model);
}
public void Update(MessageBindingModel model)
{
using (var context = new ForumDatabase())
{
var element = context.Message.FirstOrDefault(rec => rec.Id == model.Id);
if (element == null)
{
throw new Exception("Элемент не найден");
}
CreateModel(model, element);
context.SaveChanges();
}
}
public static Message ToModel(MessageBindingModel messageBindingModel)
{
Message message = new Message();
message.ReceiverId = messageBindingModel.ReceiverId;
message.SenderId = messageBindingModel.SenderId;
message.Subject = messageBindingModel.Subject;
message.Content = messageBindingModel.Content;
message.CreateAt = DateTime.Now;
message.Type = messageBindingModel.Type;
return(message);
}
public IHttpActionResult PostMessages(string friendId, [FromBody] MessageBindingModel message)
{
var userId = User.Identity.GetUserId();
if (friendId == userId)
{
return(BadRequest("You canot send messages to yourself!"));
}
if (!Data.Users.Any(u => u.Id == friendId))
{
return(BadRequest("You cannot sent message to an unexisting user!"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newMessage = new Message
{
ContentString = message.ContentString,
ContentType = "text",
SentOn = DateTime.Now,
SenderId = userId,
ReceiverId = friendId
};
Data.Messages.Add(newMessage);
if (!Data.Notifications.Any(n => n.SenderId == userId && n.ReceiverId == friendId))
{
Data.Notifications.Add(new Notification
{
SenderId = userId,
ReceiverId = friendId,
UnseenMessages = 0
});
Data.SaveChanges();
}
var notification = Data.Notifications
.First(n => n.SenderId == userId && n.ReceiverId == friendId);
notification.UnseenMessages++;
Data.SaveChanges();
return(Ok(newMessage));
}
public IActionResult Reply(HttpResponse response, MessageBindingModel bmm)
{
var message = new Message()
{
Content = bmm.Content,
Sender = "Admin",
Subject = bmm.Subject
};
context.Messages.Add(message);
context.SaveChanges();
Redirect(response, "/admin/messages");
return(null);
}
public List <MessageViewModel> Read(MessageBindingModel model)
{
if (model == null)
{
return(messageStorage.GetFullList());
}
if (model.Id.HasValue)
{
return(new List <MessageViewModel> {
messageStorage.GetElement(model)
});
}
return(messageStorage.GetFilteredList(model));
}
public List <MessageViewModel> GetFilteredList(MessageBindingModel model)
{
using (var context = new ForumDatabase())
{
return(context.Message.Include(rec => rec.Like).Where(rec => rec.Topicname.Contains(model.NameTopic) || (rec.Time > model.DateFrom && rec.Time < model.DateTo))
.Select(rec => new MessageViewModel
{
Id = rec.Id,
Text = rec.Text,
Time = rec.Time,
LoginUser = rec.Visitorlogin,
NameTopic = rec.Topicname,
}).ToList());
}
}
public IActionResult Contacts(MessageBindingModel model)
{
var message = new Message
{
Email = model.Email,
Subject = model.Subject,
MessageText = model.MessageText
};
db.Messages.Add(message);
db.SaveChanges();
return(View());
}
public void Delete(MessageBindingModel model)
{
using (var context = new ForumDatabase())
{
var element = context.Message.FirstOrDefault(rec => rec.Id == model.Id);
if (element != null)
{
context.Message.Remove(element);
context.SaveChanges();
}
else
{
throw new Exception("Элемент не найден");
}
}
}
public async Task SendMessage(MessageBindingModel inputModel)
{
var messageServiceModel = await messageService.CreateMessageAsync(inputModel.ConversationId, inputModel.SenderId, inputModel.ReceiverId, inputModel.Text);
var sender = await userManager.FindByIdAsync(messageServiceModel.SenderId);
var messageViewModel = new MessageViewModel
{
SendOn = messageServiceModel.SendOn.ToString(GlobalConstants.DateTimeFormat),
SenderName = sender.UserName,
Text = messageServiceModel.Text
};
await Clients.Users(inputModel.ReceiverId)
.SendAsync("SendMessage", messageViewModel);
}
public IActionResult SendMessage(MessageBindingModel model)
{
try
{
#region Validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
#endregion
#region MessageSaving
if (model.isUserSender)
{
model.User_Id = Convert.ToInt32(User.GetClaimValue("Id"));
}
else
{
model.Driver_Id = Convert.ToInt32(User.GetClaimValue("Id"));
}
Message msg = Mapper.Map <MessageBindingModel, Message>(model);
MessageDTO response = _bORide.InsertMessage(msg);
#endregion
#region Response
if (response == null)
{
return(Ok(new CustomResponse <Error> {
Message = Global.ResponseMessages.BadRequest, StatusCode = StatusCodes.Status400BadRequest, Result = new Error {
ErrorMessage = "Message sending failed."
}
}));
}
return(Ok(new CustomResponse <MessageDTO> {
Message = Global.ResponseMessages.Success, StatusCode = StatusCodes.Status200OK, Result = response
}));
#endregion
}
catch (Exception ex)
{
return(StatusCode(Error.LogError(ex)));
}
}
public async Task CanSaveMessage()
{
var factory = _factoryCollection.ForAdd;
using (var httpClient = factory.CreateClient())
{
int expectedCount = 4;
var model = new MessageBindingModel
{
Name = "Test Name",
Email = "*****@*****.**",
Company = "Test Company",
Subject = "Test Subject",
Text = "Test Text"
};
var json = JsonConvert.SerializeObject(model);
using (var response = await httpClient.PostAsync(BASE_URL, new StringContent(json, Encoding.UTF8, "application/json")))
{
Assert.True(response.IsSuccessStatusCode);
Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
string responseJson = await response.Content.ReadAsStringAsync();
var details = JsonConvert.DeserializeObject <OperationDetails>(responseJson);
Assert.False(details.IsError);
Assert.Equal("Thank you for your message!", details.Message);
using (var scope = factory.Server.Host.Services.CreateScope())
{
using (var db = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>())
{
Assert.Equal(expectedCount, db.Messages.Count());
var addedMessage = await db.Messages.LastOrDefaultAsync();
Assert.NotNull(addedMessage);
Assert.Equal("Test Name", addedMessage.Name);
Assert.Equal("*****@*****.**", addedMessage.Email);
Assert.Equal("Test Company", addedMessage.Company);
Assert.Equal("Test Subject", addedMessage.Subject);
Assert.Equal("Test Text", addedMessage.Text);
Assert.False(addedMessage.IsRead);
}
}
}
}
}
public IHttpActionResult EditMessage(int id, MessageBindingModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return(this.BadRequest(this.ModelState));
}
var message = this.data.ChatMessages.Find(id);
if (message == null)
{
return(this.NotFound());
}
this.data.ChatMessages.Update(message);
this.data.SaveChanges();
return(this.Ok(new { Message = string.Format("Message #{0} edited succesfully", message.Id) }));
}
public async Task <IActionResult> Send(MessageBindingModel inputModel)
{
var message = await messageService.CreateMessageAsync(inputModel.ConversationId, inputModel.SenderId,
inputModel.ReceiverId, inputModel.Text);
var sender = await this.userManager.FindByIdAsync(message.SenderId);
var messageViewModel = new MessageViewModel
{
Text = message.Text,
SenderName = sender.UserName,
SendOn = message.SendOn.ToString(GlobalConstants.DateTimeFormat),
};
await this.hubContext.Clients.User(inputModel.ReceiverId)
.SendAsync("SendMessage", messageViewModel);
return(this.Json(message));
}
// POST api/chat/5
public IHttpActionResult Post(int id, [FromBody] MessageBindingModel model)
{
string userId = User.Identity.GetUserId();
Message message;
try
{
message = ChatsService.AddUserMessage(userId, id, model);
}
catch (NullReferenceException ex)
{
return(BadRequest());
}
catch (UnauthorizedAccessException ex)
{
return(Unauthorized());
}
return(Ok(message));
}
public IHttpActionResult PostSend(MessageBindingModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return(this.BadRequest(this.ModelState));
}
var message = new ChatMessage
{
Content = model.Content,
UserId = model.UserId.ToString(),
};
this.data.ChatMessages.Add(message);
this.data.SaveChanges();
// return this.CreatedAtRoute("DefaultApi", new { id = message.Id }, message);
// return this.CreatedAtRoute("GetMessageById", new { id = message.Id }, message);
return(this.Ok(message.Id));
}
public async Task <IHttpActionResult> SentMessage(MessageBindingModel messageModel)
{
using (var ctx = ApplicationDbContext.Create()) {
var ReceiverUser = await AppUserManager.FindByNameAsync(messageModel.ReceiverUserName);
var Sender = await AppUserManager.FindByIdAsync(User.Identity.GetUserId());
var message = new Message()
{
ReceiverId = ReceiverUser.Id,
SenderId = User.Identity.GetUserId(),
Content = messageModel.Message,
Time = DateTime.Now
};
ctx.Messages.Add(message);
await ctx.SaveChangesAsync();
return(Ok());
}
}
public async Task <IActionResult> Message(MessageBindingModel messageBindingModel)
{
//get sender ID
var senderGambler = await new GamblerQueryHandler().HandleAsync(new GamblerQuery
{
Name = messageBindingModel.sender
});
Gambler sender = senderGambler.ToList().FirstOrDefault(g => g.Name == messageBindingModel.sender);
if (sender == null)
{
return(RedirectToAction(StaticConstants.All, StaticConstants.ApiMessages, new { error = StaticConstants.SenderDontExistError }));
}
//get receiver ID
var receiverGambler = await new GamblerQueryHandler().HandleAsync(new GamblerQuery
{
Name = messageBindingModel.receiver
});
Gambler receiver = receiverGambler.ToList().FirstOrDefault(g => g.Name == messageBindingModel.receiver);
if (receiver == null)
{
return(RedirectToAction(StaticConstants.All, StaticConstants.ApiMessages, new { error = StaticConstants.ReceiverDontExistError }));
}
SendMessageCommand command = new SendMessageCommand {
Body = messageBindingModel.body,
Subject = messageBindingModel.subject,
Id = Guid.NewGuid(),
FromGamblerId = sender.Id,
ToGamblerId = receiver.Id
};
var handler = new SendMessageHandler();
await handler.HandleAsync(command);
return(RedirectToAction(StaticConstants.All, StaticConstants.ApiMessages, new { message = StaticConstants.MessageSentSuccessMessage }));
}
public MessageViewModel GetElement(MessageBindingModel model)
{
if (model == null)
{
return(null);
}
using (var context = new ForumDatabase())
{
var message = context.Message.Include(rec => rec.Like).FirstOrDefault
(rec => rec.Id == model.Id);
return(message != null ? new MessageViewModel
{
Id = message.Id,
Text = message.Text,
Time = message.Time,
LoginUser = message.Visitorlogin,
NameTopic = message.Topicname,
} :
null);
}
}
