/// <summary>
/// Add a chat room to the database.
/// </summary>
/// <param name="chatRoomModel"> Chat room to add. </param>
public ChatRoomModel Add(ChatRoomModel chatRoomModel)
{
var chatRoom = new ChatRoom()
{
DisplayName = chatRoomModel.DisplayName
};
_chatContext.ChatRooms.Add(chatRoom);
_chatContext.SaveChanges();
_chatContext.Entry(chatRoom).Collection(i => i.UserRooms).Load();
// set dto model's id
chatRoomModel.Id = chatRoom.Id;
foreach (var user in chatRoomModel.Users)
{
var userRoom = new UserRoom()
{
UserId = user.Id,
ChatRoomId = chatRoom.Id
};
chatRoom.UserRooms.Add(userRoom);
}
_chatContext.SaveChanges();
return(chatRoomModel);
}
public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
public async Task <IActionResult> PutChat([FromRoute] int id, [FromBody] Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _context.Users.FindAsync(message.UserId);
var chat = await _context.Chats.Include(m => m.ChatMessages).Include(p => p.ChatUsers)
.FirstOrDefaultAsync(i => i.ChatId == id);
if (chat == null)
{
return(NotFound());
}
if (user == null)
{
return(NotFound());
}
if (!chat.ChatUsers.Where(n => n.UserId == message.UserId).Any())
{
ChatUser chatUser = new ChatUser();
chatUser.Chat = chat;
chatUser.User = user;
_context.ChatsUsers.Add(chatUser);
await _context.SaveChangesAsync();
}
chat.ChatMessages.Add(message);
_context.Entry(chat).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChatExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutScenario(int id, Scenario scenario)
{
if (id != scenario.Id)
{
return(BadRequest());
}
_context.Entry(scenario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ScenarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutChater(int id, Chater chater)
{
if (id != chater.Id)
{
return(BadRequest());
}
_context.Entry(chater).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChaterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Models.Chat> Update(Models.Chat chat)
{
_context.Entry(chat).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(chat);
}
public async Task <User> update(Guid id, User user)
{
var userUpdate = _context.Users.SingleOrDefault(u => u.Id == id);
if (userUpdate == null)
{
throw new AppException("Không tìm thấy tài khoản update !");
}
userUpdate.UserName = user.UserName;
userUpdate.FirstName = user.FirstName;
userUpdate.LastName = user.LastName;
userUpdate.AvatarUrl = user.AvatarUrl;
userUpdate.ContactMobile = user.ContactMobile;
_context.Entry(userUpdate).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw new AppException("Cập nhật thất bại !");
}
return(userUpdate);
}
public async Task <Message> Update(Message message)
{
_context.Entry(message).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(message);
}
public JsonResult MessageDelivered(int message_id)
{
Conversation convo = null;
using (var db = new ChatContext())
{
convo = db.Conversations.FirstOrDefault(c => c.Id == message_id);
if (convo != null)
{
convo.Status = Conversation.MessageStatus.Delivered;
db.Entry(convo).State = EntityState.Modified;
db.SaveChanges();
}
}
string socket_id = Request.Form["socket_id"];
var conversationChannel = getConvoChannel(convo.SenderId, convo.ReceiverId);
pusher.TriggerAsync(
conversationChannel,
"message_delivered",
convo,
new TriggerOptions()
{
SocketId = socket_id
});
return(Json(convo));
}
public async Task <IActionResult> PutChatRoom(int id, ChatRoom chatRoom)
{
if (chatRoom.chatRoomOwner == CurrentUser.usernameSession.chatUserID)
{
if (id != chatRoom.chatRoomID)
{
return(BadRequest());
}
_context.Entry(chatRoom).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ChatRoomExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
else
{
return(NotFound());
}
}
public async Task <User> Update(User user)
{
_context.Entry(user).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(user);
}
public async Task <IActionResult> PutMessage(long id, Message message)
{
if (id != message.MessageId)
{
return(BadRequest());
}
_context.Entry(message).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutConversation([FromRoute] int id, [FromBody] Conversation conversation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != conversation.Id)
{
return(BadRequest());
}
_context.Entry(conversation).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConversationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//determines if user is about to quit chat
public ActionResult Logoff(string userLogin, string userEmail, bool logoff)
{
try
{
ChatUser user = db.Users.FirstOrDefault(u => (u.Login == userLogin) && (u.Email == userEmail));
user.Online = false;
db.Messages.Add(new ChatMessage()
{
Text = user.Login + " has left chat",
User = user,
PostTime = DateTime.Now
});
db.Entry <ChatUser>(user).State = EntityState.Modified;
db.SaveChanges();
viewModel = new ChatViewModel()
{
Messages = db.Messages.ToList(),
Users = db.Users.ToList()
};
return(PartialView("ChatBox", viewModel));
}
catch (Exception ex)
{
Response.StatusCode = 500;
return(Content(ex.Message));
}
}
public async Task <IHttpActionResult> PutMessage(int id, Message message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != message.Id)
{
return(BadRequest());
}
db.Entry(message).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MessageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private ChatUser RemoveUserFromStorage(string userName)
{
ChatUser currentUser = null;
using (var db = new ChatContext())
{
currentUser = db.ChatUsers.SingleOrDefault(u => u.Name == userName);
if (currentUser != null)
{
currentUser.LeaveTime = DateTime.Now;
db.Entry(currentUser).State = System.Data.Entity.EntityState.Deleted;
db.SaveChanges();
}
//user.Connections.Add(new Connection
// {
// ConnectionID = Context.ConnectionId,
// UserAgent = Context.Request.Headers["User-Agent"],
// Connected = true
// });
}
return(currentUser);
}
public async Task EditUser(User user)
{
var res = await _context.Settings.SingleOrDefaultAsync(x => x.UserId == user.Id);
if (res == null)
{
await Task.FromException(new InvalidDataException());
}
else
{
var modelDb = _mapper.Map <UserDb>(user);
modelDb.UserName = user.UserName;
_context.Attach(modelDb);
_context.Entry(modelDb).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
private void SaveMessageToStorage(ChatMessage message)
{
using (var db = new ChatContext())
{
db.Entry(message).State = System.Data.Entity.EntityState.Added;
db.SaveChanges();
}
}
public ActionResult Edit([Bind(Include = "Id,Username,Color,PicUrl")] Profile profile)
{
if (ModelState.IsValid)
{
db.Entry(profile).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(profile));
}
public ActionResult Edit([Bind(Include = "chatlog_id,sender_name,category_id,message,timestamp")] Chatlog chatlog)
{
if (ModelState.IsValid)
{
db.Entry(chatlog).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(chatlog));
}
public ActionResult Edit([Bind(Include = "Id,Content,Timestamp")] Message message)
{
if (ModelState.IsValid)
{
db.Entry(message).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(message));
}
public ActionResult Edit([Bind(Include = "USER_ID,FIRST_NAME,LAST_NAME,AVATARLINK")] User user)
{
if (ModelState.IsValid)
{
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(user));
}
//Get messsage channels of a server
private async Task <IEnumerable <MessageChannel> > GetMessageChannelAsync(string serverKey)
{
ServerChannel server = await _Context.ServerChannels.FindAsync(serverKey);
await _Context.Entry(server).Collection(s => s.MessageChannels).LoadAsync();
if (server != null)
{
return(server.MessageChannels);
}
return(null);
}
/// <summary>
/// Adds a chat message to the database.
/// </summary>
/// <param name="message"> Message to add to the database. </param>
/// <returns> The added <see cref="ChatMessage"/> with additional fields set from the database. </returns>
public ChatMessage Add(ChatMessage message)
{
// todo: change the model on the frontend to send a model like this
message.UserId = message.User.Id;
message.User = null;
var addedMessage = _chatContext.ChatMessages.Add(message).Entity;
_chatContext.SaveChanges();
// load the user into the entity
_chatContext.Entry(addedMessage).Reference(i => i.User).Load();
return(addedMessage);
}
//Get all chat
public async Task <IEnumerable <Media> > GetChats(string Email1, string Email2)
{
var user1 = await _UserManager.FindByEmailAsync(Email1);
var user2 = await _UserManager.FindByEmailAsync(Email2);
if (user1 == null || user2 == null)
{
return(null);
}
PrivateChat map = await GetPrivateChat(user1, user2);
if (map != null)
{
try{
await Context.Entry(map).Collection(s => s.Media).LoadAsync();
List <Media> m = new List <Media>();
foreach (var b in map.Media)
{
m.Add(new Media {
Key = b.Key,
RowVersion = b.RowVersion,
TimeUtc = b.TimeUtc,
ChatId = b.ChatId,
SendFrom = b.SendFrom,
Type = b.Type,
SendFromEmail = b.SendFromEmail,
Message = b.Message,
Image = b.Image
});
} // As it is also loading Navigation Properties , so i have to explicitly create a list and the laod all the usefull data
// Also It is transferring too much data
return(m); //Get all the media or the chats
}
catch (Exception e) {
Console.WriteLine(e.Message); //CHANGE IT TO LOG
return(null);
}
}
else
{
return(null);
}
throw new NotImplementedException();
}
public async Task EditMessage(Message message, string roomId)
{
var modelDb = await _context.Messages.SingleOrDefaultAsync(x => x.Id == message.Id);
if (modelDb == null)
{
await Task.FromException(new InvalidDataException());
}
else
{
var newModelDb = _mapper.Map <MessageDb>(message);
modelDb.Text = newModelDb.Text;
modelDb.IsEdit = true;
_context.Attach(modelDb);
_context.Entry(modelDb).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
}
public async Task Update(Contact contacts)
{
db.Entry(contacts).State = EntityState.Modified;
await Save();
}
public void Update(ChatMessage chatMessage)
{
db.Entry(chatMessage).State = EntityState.Modified;
}
public void UpdateMessage(MessageDTO message)
{
var messageEntity = _mapper.Map <MessageEntity>(message);
_context.Entry(messageEntity).State = EntityState.Modified;
}
public void Update(Chat chat)
{
db.Entry(chat).State = EntityState.Modified;
}
