private void YODAHub_Message(ChatMessageDto message)
{
MessageReceived?.Invoke(
this,
new ChatEventArgs <ChatMessageDto>(new ChatEventContext(this), message)
);
}
/// <inheritdoc />
Task IChatApi.SendMessage(ChatMessageDto chatMessage)
{
var arguments = new object[] { chatMessage };
var func = requestBuilder.BuildRestResultFuncForMethod("SendMessage", new Type[] { typeof(ChatMessageDto) });
return((Task)func(Client, arguments));
}
public IHttpActionResult Get(int id)
{
ChatMessage entity = this.service.Get(id, collections: false);
ChatMessageDto dto = ModelMapper.Map <ChatMessageDto>(entity);
return(Ok(dto));
}
private void Ready()
{
Receive <ChatCreatedEvent>(@event =>
{
var chat = new ChatDto()
{
ChatId = @event.Id
};
chat.Participants = @event.Participants
.Select(x => new ChatParticipantDto()
{
Id = x.Id, Login = x.Login
}).ToList();
string path = "chats/" + @event.Id;
PushResponse response = client.Push(path, chat);
});
Receive <ChatMessageAddedEvent>(@event =>
{
string path = String.Format("chats/{0}/{1}", @event.ChatId, "messages");
ChatMessageDto messageDto = new ChatMessageDto()
{
MessageId = @event.MessageId,
Date = @event.Date,
Message = @event.Message,
UserId = @event.Author.Id,
UserName = @event.Author.Login
};
PushResponse response = client.Push(path, messageDto);
});
}
public async Task <ChatMessageDto> PostChatMessage(ChatMessageDto model)
{
var url = CRMApiUri + "/ChatMessage";
var result = await PostRequestToApi(url, model);
return(result);
}
public async Task <ChatMessageDto> PutChatMessage(int id, ChatMessageDto model)
{
var url = CRMApiUri + "/ChatMessage/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task PostChatMessage(string receiverId, ChatMessageNewDto chatMessageNew)
{
await ValidateMessagePosting(receiverId, chatMessageNew);
var senderId = _currentUserService.GetUserId();
var chatMessage = new ChatMessage
{
ReceiverId = receiverId,
SenderId = senderId,
Timestamp = _timeService.GetCurrentTime(),
Content = chatMessageNew.Content,
ModuleId = chatMessageNew.ModuleId
};
await _chatMessagesRepository.Create(chatMessage);
var sender = await _userManager.FindByIdAsync(senderId);
var chatMessageDto = new ChatMessageDto
{
SenderId = chatMessage.SenderId,
Timestamp = chatMessage.Timestamp,
SenderName = $"{sender.FirstName} {sender.LastName}",
Content = chatMessage.Content
};
await _hubsService.SendChatNotificationToUser(senderId, chatMessageDto);
await _hubsService.SendChatNotificationToUser(receiverId, chatMessageDto);
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(ChatMessageDto entityDto)
{
var entity = _mapper.Map <ChatMessage>(entityDto);
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public ActionResult SendMessage(string userid, string sendtext)
{
var result = new StandardJsonResult <bool>();
result.Try(() => {
Guid messageid = Guid.NewGuid();
userid = userid.Replace(",", "|");
userid = userid + "|" + BCSession.User.UserID;
ChatMessageDto cd = new ChatMessageDto()
{
EnterpriseID = BCSession.User.EnterpriseID,
IsRead = ReadStatus.NoRead,
Message = sendtext,
MessageID = messageid,
Recipients = userid,
SendTime = DateTime.Now,
SendUserID = BCSession.User.UserID,
SendUserName = BCSession.User.UserName,
};
result.Value = serrvice.ProcessChatMessage(cd);
if (!result.Value)
{
result.Message = "发送失败";
}
result.Message = "发送成功";
});
if (!result.Success)
{
result.Message = "发送失败";
}
return(result);
}
public async Task <IActionResult> Post([FromBody] ChatMessageDto chatMessage)
{
if (chatMessage.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _chatMessageService.SaveAndReturnEntityAsync(chatMessage)));
}
public async Task <IActionResult> Put(int id, [FromBody] ChatMessageDto chatMessage)
{
if (id == 0 || chatMessage.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _chatMessageService.SaveAndReturnEntityAsync(chatMessage)));
}
private void InsertMessage(ChatMessageDto message)
{
try
{
_chatService.Create(message);
}
catch (Exception ex)
{
return;
}
}
// messenger id van dto vervangen met current principal id
public IHttpActionResult Post([FromBody] ChatMessageDto dto)
{
dto.Timestamp = dto.Timestamp ?? DateTime.Now;
ChatMessage entity = ModelMapper.Map <ChatMessage>(dto);
this.service.Add(entity);
dto = ModelMapper.Map <ChatMessageDto>(entity);
return(Ok(dto));
}
private void OnMessage(ChatMessageDto message)
{
OnUserUpdate(message.UserInfo);
_messages.Enqueue(message);
var action = OnChatMessage;
if (action != null)
{
MainThread.Post(() => action(message));
}
}
private void SendServerMessage(string message)
{
var dto = new ChatMessageDto
{
IsSystemMessage = true,
Message = message,
SourceColour = null,
Source = null,
Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
};
_eventSender.SendEvent(ServerEvent.ChatMessage, dto, null);
}
public async Task SendChatMessage(ChatMessageDto chatMessageDto)
{
try
{
await _chatApiService.SendMessage(chatMessageDto);
_chatsForUser.Edit(l => l.AddOrUpdate(chatMessageDto));
}
catch (Exception ex)
{
_logger.Error(nameof(SendChatMessage), ex);
throw;
}
}
public string Send([FromBody] ChatMessageDto messageDto)
{
try
{
var message = new ChatMessage(messageDto);
_dbContext.ChatMessages.Add(message);
_dbContext.SaveChanges();
return("Meddelandet har skickats!");
}
catch
{
return("Något gick fel!");
}
}
public async Task SendChatMessageAsync(ChatMessageDto chatMessageDto)
{
var chatMessageEntity = mapper.Map <ChatMessageEntity>(chatMessageDto);
await chatMessageRepository.InsertAsync(chatMessageEntity);
await gameRepository.AddMessageIdToGameAsync(chatMessageDto.GameId, chatMessageEntity.Id);
var chatMessageToSendDto = mapper.Map <ChatMessageToSendDto>(chatMessageEntity);
var sender = await userRepository.GetAsync(chatMessageDto.UserId);
chatMessageToSendDto.UserName = sender.Login;
var groupName = chatMessageDto.GameId.ToString();
await Clients.Group(groupName).SendAsync("SendChatMessage", chatMessageToSendDto);
}
public async Task SendMessage(string message)
{
var formatedMessage = new ChatMessageDto()
{
Message = message,
Timestamp = DateTime.Now.ToString("HH:mm:ss tt"),
User = new UserHub()
{
UserName = Context.User.Identity.Name,
Role = Context.User.Identities.First().Claims.ToArray()[1].Value
}
};
await Clients.All.SendAsync("NewMessage", JsonSerializer.Serialize(formatedMessage));
}
public IEnumerable <ChatMessageDto> ListChatMessages(string uid)
{
return(_db.ChatRooms.FirstOrDefault(room => room.Id == uid).Messages
.OrderByDescending(msg => msg.Created)
.Select(message =>
{
ChatMessageDto dto = new ChatMessageDto();
dto.Id = message.Id;
dto.Text = message.Text;
dto.ChatRoomId = uid;
dto.Username = message.Username;
dto.Created = message.Created.ToString("yyyy.MM.dd. HH:mm:ss");
return dto;
}));
}
public async Task Handle(ChatMessageReceivedNotification notification, CancellationToken cancellationToken)
{
var(_, participants, message, channel, messagesCount) = notification;
ChatMessageSender?sender = null;
if (!message.Options.IsAnonymous)
{
sender = message.Sender;
}
var channelId = ChannelSerializer.Encode(channel).ToString();
var messageDto = new ChatMessageDto(messagesCount - 1, channelId, sender, message.Message,
message.Timestamp, message.Options);
var participantGroups = participants.Select(CoreHubGroups.OfParticipant);
await _hubContext.Clients.Groups(participantGroups).ChatMessage(messageDto, cancellationToken);
}
public IResponse <string> Validate(ChatMessageDto dto)
{
var response = new Response <string>();
if (dto.Id == Guid.Empty)
{
response.Errors.Add("invalid game instance");
}
if (string.IsNullOrWhiteSpace(dto.Text) || dto.Text.Length > 500)
{
response.Errors.Add("invalid message text");
}
var gameInstance = GameInstanceLogic.Get(dto.Id);
if (gameInstance == null || !gameInstance.Users.Any(x => x.UserId == RequestContext.UserId))
{
response.Errors.Add("That game is invalid.");
}
return(response);
}
public async Task SendMessage(ChatMessageDto dto)
{
var validationResults = GameInstanceValidator.Validate(dto);
if (!validationResults.IsValid)
{
throw new Exception(string.Join(',', validationResults.Errors));
}
var messageToSave = new GameInstanceUserMessage();
messageToSave.Text = dto.Text;
messageToSave.UserId = RequestContext.UserId;
messageToSave.GameInstanceId = dto.Id;
var entity = GameInstanceUserMessageLogic.Save(messageToSave);
var responseDto = GameInstanceMapper.Map(entity);
responseDto.UserEmail = RequestContext.Email;
await Clients.Group(dto.Id.ToString()).SendAsync("ReceiveMessage", responseDto);
}
private void AuthorizePost(HttpActionContext actionContext)
{
int participantId;
string controller = actionContext.ControllerContext.ControllerDescriptor.ControllerName;
switch (controller)
{
case "ChatMessage":
ChatMessageDto message = (ChatMessageDto)actionContext.ActionArguments["dto"];
Session session = this.Sessions.Get(message.SessionId, collections: true);
this.AuthorizeParticipant(session.Participants);
return;
default: // to prevent the dto from being null
participantId = -1;
break;
}
this.AuthorizeParticipant(participantId);
}
public async Task SendMessage()
{
if (!string.IsNullOrEmpty(NewMessage) && CurrentRoom.Id > 0)
{
var msg = new ChatMessageDto
{
UserId = CurrentUser.Id,
ChatRoomId = CurrentRoom.Id,
Message = NewMessage,
Time = DateTime.Now,
UserName = CurrentUser.Name
};
msg.Id = ChatFacade.SendMessageToChatRoom(CurrentUser, msg);
Messages.Add(msg);
NewMessage = "";
await Service.ChangeViewModelForConnectionsAsync((ChatViewModel viewModel) => { viewModel.Messages.Add(msg); },
ChatFacade
.GetAllUsersFromChatRoom(CurrentRoom.Id)
.Select(s => s.ConnectionId)
.ToList());
}
}
public async Task <ApiResponse <ChatMessageDto> > SaveMessageAsync(Guid userId, AddChatMessageDto chatMessage)
{
var newMessage = new ChatMessage
{
Id = Guid.NewGuid(),
UserId = userId,
MessageContent = chatMessage.MessageContent,
MessageSubject = chatMessage.MessageSubject,
ReceiverId = chatMessage.ReceiverId,
SenderId = chatMessage.SenderId
};
var savedMessage = await _chatMessagesRepository.AddAsync(newMessage);
if (savedMessage != null)
{
var addedMessage = new ChatMessageDto
{
Id = savedMessage.Id,
SenderId = savedMessage.SenderId,
ReceiverId = savedMessage.ReceiverId,
MessageSubject = savedMessage.MessageSubject,
MessageContent = savedMessage.MessageContent
};
return(new ApiResponse <ChatMessageDto>
{
Result = addedMessage
});
}
else
{
return(new ApiResponse <ChatMessageDto>()
.SetAsFailureResponse(Errors.Chat.ChatMessageCannotBeSaved()));
}
}
public async Task <ChatMessageDto> AddChatMessage([FromBody] ChatMessageDto chatMessageDto)
{
ChatRoom room = _db.ChatRooms.FirstOrDefault(room => room.Id == chatMessageDto.ChatRoomId);
var message = new ChatMessage()
{
Id = Guid.NewGuid().ToString(),
Text = chatMessageDto.Text,
ChatRoom = room,
Username = chatMessageDto.Username,
Created = DateTime.Now
};
room.Messages.Add(message);
_db.Update(room);
_db.SaveChanges();
chatMessageDto.Id = message.Id;
chatMessageDto.Created = message.Created.ToString("yyyy.MM.dd. HH.mm.ss");
await _hub.Clients.All.SendAsync("NewChatMessage", chatMessageDto);
return(chatMessageDto);
}
public HttpResponseMessage SendMessage(ChatMessageDto message)
{
var responce = this.Request.CreateResponse(HttpStatusCode.OK);
return(responce);
}
public async Task Invoke(HttpContext context)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await _next.Invoke(context);
return;
}
CancellationToken ct = context.RequestAborted;
WebSocket currentSocket = await context.WebSockets.AcceptWebSocketAsync();
var socketId = Guid.NewGuid().ToString();
UserDto userFromSession = GetUserFromSesion(context);
RoomDto roomFromSession = GetRoomFromSesion(context);
WebSocketConfig config = new WebSocketConfig()
{
Id = socketId, RoomId = roomFromSession.Id, UserId = userFromSession.Id
};
_sockets.TryAdd(config, currentSocket);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var response = await ReceiveStringAsync(currentSocket, ct);
ChatMessageDto message = JsonConvert.DeserializeObject <ChatMessageDto>(response);
UserDto user = GetUser(message.UserID);
message.CreatedAt = DateTime.Now;
InsertMessage(message);
if (message.User == null)
{
message.User = new UserDto();
}
message.User.Name = user != null ? user.Name : "---";
if (config.UserId == Guid.Empty || config.RoomId == Guid.Empty)
{
config.UserId = message.UserID;
config.RoomId = message.RoomID;
}
if (string.IsNullOrEmpty(response))
{
if (currentSocket.State != WebSocketState.Open)
{
break;
}
continue;
}
foreach (var socket in _sockets)
{
if (socket.Value.State != WebSocketState.Open)
{
continue;
}
if (socket.Key.RoomId == config.RoomId)
{
string messageToSend = JsonConvert.SerializeObject(message, Formatting.Indented);
await SendStringAsync(socket.Value, messageToSend, ct);
}
}
}
WebSocket dummy;
_sockets.TryRemove(config, out dummy);
await currentSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", ct);
currentSocket.Dispose();
}
/// <summary>
/// Broadcasts the chat message to all the clients
/// </summary>
/// <param name="message"></param>
public void SendMessage(ChatMessageDto message)
{
IHubContext context = GlobalHost.ConnectionManager.GetHubContext("ChatRHub");
context.Clients.All.pushNewMessage(message.Id, message.ParticipantId, message.ParticipantName, message.Content, message.Time);
}