public ChatMessageDTO AddMessage(Guid userId, DateTime timeSendMessage, string message, string name)
{
var chatMessage = new ChatMessage
{
IndexMessage = _efUnitOfWork.MessagesRepository.GetAll().Count() + 1,
UserId = userId,
TimeSendMessage = timeSendMessage,
Message = message
};
_efUnitOfWork.MessagesRepository.Create(chatMessage);
var chatMessageDTO = new ChatMessageDTO
{
Id = chatMessage.IndexMessage,
SenderName = name,
DateSend = timeSendMessage.ToString(),
SendMessage = message
};
_sessionData.DataMessages.Add(chatMessageDTO);
SaveAsync();
return(chatMessageDTO);
}
public async Task <IActionResult> Post([FromBody] ChatMessageDTO message)
{
var m = await chatService.SendMessage(message);
return(m == null?StatusCode(409) as IActionResult
: Ok(m));
}
public void Add(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
chatMessageDAL.Add(chatmessage);
chatMessageDAL.Commit();
}
/// <summary>
/// 向所有客户端发送消息
/// </summary>
/// <param name="message"></param>
public async Task Send(string message)
{
try
{
//当前发送消息的用户ID，前端自定义
string userId = ClientQueryString["userId"];
//当前连接ID
string connId = "";//Context.ConnectionId;
UserIdDict.TryGetValue(userId, out connId);
connId = string.IsNullOrEmpty(connId) ? Context.ConnectionId : connId;
// 调用所有客户端的SendMessage方法
ChatMessageDTO msg = new ChatMessageDTO
{
SendId = connId,
Content = message,
CreateDate = DateTime.Now
};
await _serverToClient.SendMessageByUserId(connId, $"服务器收到了[{connId}]发送的消息，准备广播给所有在线用户。");
await _serverToClient.SendMessageFormAllOnlineUser(msg);
}
catch (Exception e)
{
throw new HubException("发送消息发生异常.", new { userName = ClientContextUser.Identity.Name, message = e.Message });
}
}
public async Task <IActionResult> SendMessageFromChat(ChatMessageDTO message)
{
_logger.Info($"{"ChatMessageController:",-20} >>> {"SendMessageFromChat",-20} >>> {"Start: Model:",-10} {JsonConvert.SerializeObject(message)}.");
var connectionId = "";
//if (message is null || !ModelState.IsValid)
//{
// _logger.Debug($"{"ChatMessageController:",-20} >>> {"SendMessageFromChat",-20} >>> {"Start: ModelState is valid:",-10} {ModelState.IsValid,-20} >>> {"Model is null:",-10}{message.Equals(null)}.");
// return BadRequest();
//}
var sendResult = await _chatService.SendMessageFromChat(message);
_logger.Debug($"{"ChatMessageController:",-20} >>> {"SendMessageFromChat",-20} >>> {"Start: model:",-10} {JsonConvert.SerializeObject(message),-20} >>> {"Responce:",-10}{sendResult}.");
if (sendResult > 0)
{
if (connectionId != null)
{
await _chatHubContext.Clients.Client(connectionId).SendAsync("SendMessageFromChat", message);
}
_logger.Info($"SEND SUCCESS.");
return(Ok(sendResult));
}
return(BadRequest());
}
/// <summary>
/// 新增指定人员发送到指定接收人员的消息
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public async Task AddAsync(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
await chatMessageDAL.AddAsync(chatmessage);
await chatMessageDAL.CommitAsync();
}
public bool AddChatMessage(ChatMessageDTO chatMessage, string GameID)
{
var session = context.GameSessions
.Include(gs => gs.Chatlog)
.Where(g => g.Id.Equals(GameID))
.FirstOrDefault();
if (session == null)
{
throw new ArgumentException($"Game {GameID} not found");
}
if (session.Chatlog == null)
{
session.Chatlog = new List <ChatMessage>();
}
context.GameSessions.Where(g => g.Id.Equals(GameID))
.FirstOrDefault()
.Chatlog
.Add(new ChatMessage
{
GameSessionID = GameID,
Message = chatMessage.Message,
TimeStamp = chatMessage.TimeStamp,
Username = chatMessage.Username
});
return(context.SaveChanges() > 0 ? true : false);
}
public List <ChatMessageDTO> GetFilters(ChatMessageDTO t, DateTime startTime, DateTime endTime)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var list = chatMessageDAL.GetFilters(chatmessage, startTime, endTime);
return(ChatMessageMapperToDTO.MapEnum(list).ToList());
}
public async Task <int> SendMessageFromChat(ChatMessageDTO message)
{
_logger.Info($"{"ChatService:",-20} >>> {"SendMessageFromChat",-20} >>> {"Start model:",-10} {JsonConvert.SerializeObject(message)}.");
if (message == null)
{
return(0);
}
var res = await _chatRepository.SaveMessageToDB(message);
_logger.Debug($"{"ChatService:",-20} >>> {"SendMessageFromChat",-20} >>> {"Save:",-10} {res}.");
return(res);
//if (res.Result != 0)
//{
// var clientModel = new ChatMessageDTO
// {
// SessionId = message.SessionId,
// ChatId = message.ChatId,
// MessageDateTime = message.MessageDateTime,
// MessageContent = "testContent",
// IsRead = message.IsRead,
// SenderUserId = message.SenderUserId,
// IsGroup = message.IsGroup,
// GroupId= message.GroupId
// };
//}
}
public ChatMessageDTO GetEntity(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var result = chatMessageDAL.GetEntity(chatmessage);
return(ChatMessageMapperToDTO.Map(result));
}
/// <summary>
/// 向所有客户端发送消息
/// </summary>
/// <param name="message"></param>
public async Task Send(string message)
{
//当前连接ID
string connId = Context.ConnectionId;
try
{
// 调用所有客户端的SendMessage方法
ChatMessageDTO msg = new ChatMessageDTO
{
SendId = connId,
SendUserName = "",
Content = message,
CreateDate = DateTime.Now
};
message = connId + "发送内容>>" + message;
Console.WriteLine(message);
await Clients.All.SendMessage(msg);
}
catch (Exception e)
{
throw new HubException("发送消息发生异常.", new { message = e.Message });
}
finally
{
SignalrServerToClient.BroadcastMessage($"服务端已经接收到[{connId}]发来的消息，消息内容为：{message}");
}
}
public List <ChatMessageDTO> GetFilters(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var list = chatMessageDAL.GetFilters(chatmessage);
return(ChatMessageMapperToDTO.MapEnum(list).ToList());
}
/// <summary>
/// 获取指定的人员的单个聊天信息(A到B)
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public async Task <ChatMessageDTO> GetEntityAsync(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var result = await chatMessageDAL.GetEntityAsync(chatmessage);
return(ChatMessageMapperToDTO.Map(result));
}
public void Update(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
chatMessageDAL.Update(chatmessage);
chatMessageDAL.Commit();
}
public IHttpActionResult SendMessage(ChatMessageDTO message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ChatUserContext context = _chatmanager.GetContextByUserId(message.SenderUserId);
if (context == null)
{
return(BadRequest(string.Format("user context with id {0} not found", message.SenderUserId)));
}
Logger.Info("{0}({1}) sends {2}. ImageUrl={3}", context.User.Name, context.User.UserId, message.Message, message.ImageUrl ?? "<NONE>");
message.SenderUserAvatar = context.User.Avatar;
ChatHubContext.Current.SendChatMessage(message);
// Sql Database Lab
// Sql Database Lab
return(Ok());
}
public async Task <List <ChatMessageDTO> > GetAllAsync()
{
var chatMessageDTOs = new List <ChatMessageDTO>();
var chatMessages = await _context.ChatMessages.OrderBy(x => x.SystemDateTime).ToListAsync();
foreach (var chatMessage in chatMessages)
{
var userInfo = ADUserInfo.GetByUserName(chatMessage.UserName);
var chatMessageDTO = new ChatMessageDTO
{
ChatMessageId = chatMessage.Id,
Message = chatMessage.Message,
SystemDateTime = chatMessage.SystemDateTime,
User = $"{userInfo.FirstName} {userInfo.LastName}",
UserName = chatMessage.UserName,
Image = null
};
chatMessageDTOs.Add(chatMessageDTO);
}
return(chatMessageDTOs);
}
public async Task <ActionResult> Add(ChatMessageDTO chatMessageDTO)
{
chatMessageDTO.Id = Guid.NewGuid().ToString();
await chatMessageBLL.AddAsync(chatMessageDTO);
return(Content("ok"));
}
/// <summary>
/// 查询指定日期范围内的人员之间的聊天信息（A和B彼此单向）
/// </summary>
/// <param name="t"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <returns></returns>
public async Task <List <ChatMessageDTO> > GetFiltersAsync(ChatMessageDTO t, DateTime startTime, DateTime endTime)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var list = await chatMessageDAL.GetFiltersAsync(chatmessage, startTime, endTime);
return(ChatMessageMapperToDTO.MapEnum(list).ToList());
}
public async Task SendMessage(string message, string userName)
{
var chatMessage = new ChatMessage
{
Id = Guid.NewGuid(),
Message = message,
SystemDateTime = DateTime.UtcNow,
UserName = userName
};
await _unitOfWork.ChatMessageRepository.PostAsync(chatMessage);
await _unitOfWork.SaveAsync();
var userInfo = ADUserInfo.GetByUserName(userName);
var dto = new ChatMessageDTO
{
ChatMessageId = chatMessage.Id,
Message = chatMessage.Message,
User = $"{userInfo.FirstName} {userInfo.LastName}",
UserName = userName,
SystemDateTime = chatMessage.SystemDateTime,
Image = userInfo.Image
};
await Clients.All.SendAsync("ReceiveMessage", dto);
}
public async Task <ActionResult> Add(ChatMessageDTO chatMessageDTO)
{
chatMessageDTO.IsDeleted = false;
chatMessageDTO.CreateTime = DateTime.Now;
await chatMessageBLL.AddAsync(chatMessageDTO);
return(Content("ok"));
}
public ActionResult Index()
{
//所有的人
var chatMessageDTO = new ChatMessageDTO();
var onlinelist = chatUserBLL.GetFilters(e => true);
return(View(onlinelist));
}
/// <summary>
/// Метод, который отвечает за считывание сообщений из базы данных и из временного контейнера (создан, чтобы постоянно не обращаться к базе данных)
/// </summary>
/// <param name="chatMessageId"> Номер ID, который указывает, каким было предыдущее отправленное сообщение </param>
/// <returns> Возвращает список первых ста или меньше сообщений </returns>
public List <ChatMessageDTO> GetChatMessages(int chatMessageId = -1)
{
var list = new List <ChatMessageDTO>();
if (_sessionData.DataMessages.Count == 0)
{
List <ChatMessage> fullList = _efUnitOfWork.MessagesRepository.GetAll().ToList();
int lastIndex = fullList.Count >= 100 ? fullList.Count - 101 : -1;
for (int i = fullList.Count - 1; i > lastIndex; i--)
{
_sessionData.DataMessages.Add(GetReadyData(fullList[i]));
}
_sessionData.SortList();
return(_sessionData.DataMessages);
}
if (_sessionData.DataMessages.Count >= 100 && chatMessageId == -1)
{
for (int i = _sessionData.DataMessages.Count - 100; i < _sessionData.DataMessages.Count; i++)
{
list.Add(_sessionData.DataMessages[i]);
}
return(list);
}
if (_sessionData.DataMessages.Count < 100 && chatMessageId == -1)
{
return(_sessionData.DataMessages);
}
ChatMessageDTO message = (from data in _sessionData.DataMessages
where data.Id == chatMessageId
select data).ToList()[0];
int index = _sessionData.IndexOf(message);
if (index >= 100)
{
int startIndex = index - 100;
for (int i = startIndex; i < index; i++)
{
list.Add(_sessionData.DataMessages[i]);
}
return(list);
}
var listData = _efUnitOfWork.CertainMessages.GetMessagesBeforeId(_sessionData.DataMessages[0].Id).ToList();
int needCountData = listData.Count > 100 - index ? listData.Count - 100 - index : 0;
for (int i = listData.Count - 1; i >= needCountData; i--)
{
_sessionData.AddStart(GetReadyData(listData[i]));
}
for (int i = 0; i < _sessionData.DataMessages.IndexOf(message); i++)
{
list.Add(_sessionData.DataMessages[i]);
}
return(list);
}
public List <ChatMessageDTO> GetFilterByBoths(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
var list = chatMessageDAL.GetFilterByBoths(chatmessage);
//按照创建日期排序
list = list.OrderBy(e => e.CreateTime).ToList();
return(ChatMessageMapperToDTO.MapEnum(list).ToList());
}
public async Task <JsonResult> GetDataLoad(string Sender, string Receiver)
{
var chatMessageDTO = new ChatMessageDTO()
{
Sender = Sender, Receiver = Receiver
};
var list = (await chatMessageBLL.GetFilterByBothsAsync(chatMessageDTO));
return(Json(list, JsonRequestBehavior.AllowGet));
}
void AddMessageToCache(ChatMessageDTO dto)
{
_MessagesCache.Enqueue(dto);
ChatMessageDTO trash;
while (_MessagesCache.Count > _NbrMessagesToKeep)
{
_MessagesCache.TryDequeue(out trash);
}
}
public async Task <ChatMessageResponse> CreateChatMessageAsync(CreateChatMessage chatMessage)
{
// User should already be authorized
ChatMessageResponse chatMessageResponse = new ChatMessageResponse();
try
{
User user = chatMessage.User;
Guid chatGroupUuid = chatMessage.ChatGroupUuid;
ChatGroup chatGroup = await _chatGroupRepository.GetByUuidAsync(chatGroupUuid);
if (chatGroup == null)
{
string messageStr = ResourceNotFoundMessage("ChatGroup", chatGroupUuid);
return(new ChatMessageResponse {
ErrorMessage = messageStr
});
}
ChatMessage saveChatMessage = new ChatMessage()
{
UserId = user.Id,
User = user,
ChatGroupId = chatGroup.ChatGroupId,
ChatGroup = chatGroup,
Message = chatMessage.Message,
};
//Save the message
await _chatMessageRepository.AddMessageAsync(saveChatMessage);
await _unitOfWork.CompleteAsync();
ChatMessageDTO chatMessageDTO = new ChatMessageDTO
{
Uuid = saveChatMessage.Uuid,
Message = saveChatMessage.Message,
CreatedOn = saveChatMessage.CreatedOn,
ChatGroupName = saveChatMessage.ChatGroup.ChatGroupName,
ChatGroupUuid = saveChatMessage.ChatGroup.Uuid,
UserName = saveChatMessage.User.UserName,
UserUuid = saveChatMessage.User.Id
};
//ChatMessageDTO messageResource = _mapper.Map<Message, FromMessageDTO>(message);
chatMessageResponse.Success = true;
chatMessageResponse.ChatMessageDTO = chatMessageDTO;
}
catch (Exception ex)
{
// Do some logging stuff
chatMessageResponse.ErrorMessage = "An error occurred when saving the message";
}
return(chatMessageResponse);
}
/// <summary>
/// Send a message to the hub
/// </summary>
/// <param name="message">message to send</param>
public async Task SendAsync(string message)
{
if (!_started)
{
throw new InvalidOperationException("Client not started");
}
var messageModel = new ChatMessageDTO(_username, message, DateTimeOffset.Now);
await _hubConnection.SendAsync(Messages.SEND, messageModel);
}
public void Delete(ChatMessageDTO t)
{
var chatmessage = ChatMessageDTOMapperToModel.Map(t);
//redis中对应的ChatMessage
var entity = chatMessageDAL.GetEntity(chatmessage);
//删除redis中指定的ChatMessage
chatMessageDAL.Delete(chatmessage);
//事务提交
chatMessageDAL.Commit();
}
public void SendMessage([FromBody] MessageToSend message)
{
var messageDTO = new ChatMessageDTO
{
Message = message.message,
TimeStamp = DateTime.Now,
Username = _GameRepo.GetUserNameFromId(_signInManager.UserManager.GetUserId(User))
};
_GameRepo.AddChatMessage(messageDTO, message.gameID);
}
void AddMessageToCache(ChatMessageDTO dto)
{
_MessagesCache.Enqueue(dto);
ChatMessageDTO trash;
while (_MessagesCache.Count > _NbrMessagesToKeep)
{
_MessagesCache.TryDequeue(out trash);
}
}
public int IndexOf(ChatMessageDTO chatMessage)
{
foreach (var message in DataMessages)
{
if (message.Id == chatMessage.Id)
{
return(DataMessages.IndexOf(message));
}
}
return(-1);
}
void OnMessageReceived(Packet<IScenePeerClient> packet)
{
var dto = new ChatMessageDTO();
ChatUserInfo temp;
if (_UsersInfos.TryGetValue(packet.Connection.Id, out temp) == false)
{
temp = new ChatUserInfo();
temp.ClientId = packet.Connection.Id;
temp.User = "";
}
dto.UserInfo = temp;
dto.Message = packet.ReadObject<string>();
dto.TimeStamp = _env.Clock;
AddMessageToCache(dto);
_scene.Broadcast("chat", dto, PacketPriority.MEDIUM_PRIORITY, PacketReliability.RELIABLE);
}
Task OnDisconnected(DisconnectedArgs args)
{
if (_UsersInfos.ContainsKey(args.Peer.Id) == true)
{
ChatUserInfo temp;
_UsersInfos.TryRemove(args.Peer.Id, out temp);
ChatMessageDTO dto = new ChatMessageDTO();
dto.UserInfo = temp;
dto.Message = args.Reason;
foreach (IScenePeerClient clt in _scene.RemotePeers)
{
if (clt.Routes.Select(x => x.Name == "DiscardInfo").Any())
{
clt.Send<ChatMessageDTO>("DiscardInfo", dto, PacketPriority.MEDIUM_PRIORITY, PacketReliability.RELIABLE);
}
};
}
return Task.FromResult(true);
}
