public void BroadcastDeferred(ChatMessageResponse value) =>
Channel.BroadcastDeferred(SCCategory.Chat, SCChat.Normal, (SPacketWriter writer) =>
{
writer.Write(value.Character);
writer.WriteChatType(value.Chat);
writer.WriteByteLengthUnicodeString(value.Message);
});
public ChatServerActor()
{
Receive <ConnectRequest>(request =>
{
_clients.Add(Sender);
var response = new ConnectResponse(request.User);
foreach (var client in _clients)
{
client.Tell(response, Self);
}
});
Receive <ChatMessageRequest>(request =>
{
var response = new ChatMessageResponse(request.User, request.Message);
foreach (var client in _clients)
{
if (!client.Equals(Sender))
{
client.Tell(response, Self);
}
}
});
}
public void BroadcastAsync(ChatMessageResponse value) =>
Dimension.BroadcastAsync(ClientOpcode.ChatMessage, (PacketWriter writer) =>
{
writer.Write(value.Character);
writer.WriteChatType(value.Chat);
writer.WriteByteLengthUnicodeString(value.Message);
});
public SSessionBase SendDeferred(ChatMessageResponse value) =>
SendDeferred(SCCategory.Chat, SCChat.Normal, (SPacketWriter writer) =>
{
writer.Write(value.Character);
writer.WriteChatType(value.Chat);
writer.WriteByteLengthUnicodeString(value.Message);
});
public SSessionBase SendAsync(ChatMessageResponse value) =>
SendAsync(ClientOpcode.ChatMessage, (PacketWriter writer) =>
{
writer.Write(value.Character);
writer.WriteChatType(value.Chat);
writer.WriteByteLengthUnicodeString(value.Message);
});
public async Task SendMessageAsync(string message)
{
var response = new ChatMessageResponse {
UserName = myName, Message = message
};
Broadcast(room).OnSendMessage(response);
await Task.CompletedTask;
}
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);
}
private ChatMessageResponse ConvertMessage(ChatMessage chatMessage, User sender, User receiver)
{
var senderName = sender.Id == chatMessage.SenderUserId ? sender.Username : receiver.Username;
var result = new ChatMessageResponse
{
ChatMessage = chatMessage,
SenderName = senderName
};
return(result);
}
public Task ReceiveWhisper(ObjectID senderId, string message, ChatLanguage language)
{
var chatResponse = new ChatMessageResponse()
{
// TODO: language support needed here
Language = ChatLanguage.Universal,
Message = message,
MessageType = ChatMessageType.Whisper,
SenderId = senderId,
Tag = ChatTag.None,
TargetId = State.Id,
};
return(Send(chatResponse));
}
public override void HandleYell(ObjectEntity objectEntity, string message, ChatLanguage language)
{
base.HandleYell(objectEntity, message, language);
var chatResponse = new ChatMessageResponse()
{
Language = language,
Message = message,
MessageType = ChatMessageType.Yell,
SenderId = objectEntity.Id,
Tag = ChatTag.None,
TargetId = State.Id,
};
Send(chatResponse).Wait();
}
public async Task CreateMessage(CreateChatMessageDTO chatMessageDTO)
{
string userEmail = Context.UserIdentifier;
User user = await _userManager.FindByEmailAsync(userEmail);
CreateChatMessage chatMessage = new CreateChatMessage
{
User = user,
Message = chatMessageDTO.Message,
ChatGroupUuid = chatMessageDTO.ChatGroupUuid
};
ChatMessageResponse chatMessageResponse = await _chatMessageService.CreateChatMessageAsync(chatMessage);
await SendMessage(chatMessageResponse);
}
private async Task SendWhisper(ChatMessageRequest request)
{
var characterList = GrainFactory.GetGrain <ICharacterList>(ShardName);
var characterId = await characterList.GetCharacterByName(request.TargetName);
if (characterId != null)
{
var character = GrainFactory.GetGrain <ICharacter>(characterId.Value);
// technically a race condition, but probably okay
if (await character.IsOnline())
{
var myEntity = await ActiveCharacter.GetCharacterEntity();
await character.ReceiveWhisper(myEntity.Id, request.Message, request.Language);
var chatConfirm = new ChatMessageResponse()
{
// TODO: language support needed here
Language = ChatLanguage.Universal,
Message = request.Message,
MessageType = ChatMessageType.WhisperConfirm,
// sender and target are reversed for WhisperConfirm
SenderId = characterId.Value,
Tag = ChatTag.None,
TargetId = myEntity.Id,
};
await Send(chatConfirm);
}
else
{
// TODO: "character is not online" notification
}
}
else
{
// TODO: "character does not exist" notification
}
}
public async Task <ActionResult <ChatMessageResponse> > CreateChatMessage([FromBody] CreateChatMessageDTO chatMessageDTO)
{
string userEmail = User.FindFirstValue(ClaimTypes.Email);
User user = await _userManager.FindByEmailAsync(userEmail);
if (user == null)
{
return(NotFound(new ChatMessageResponse {
Success = false, ErrorMessage = "User does not exist"
}));
}
ChatGroupUser chatGroupUser = await _chatGroupUserService.GetByUserAndChatGroupAsync(
user.Id, chatMessageDTO.ChatGroupUuid);
// Check if user is authorized to create chat messages for the chat group
AuthorizationResult isAuthorized = await _authorizationService.AuthorizeAsync(
User,
chatGroupUser,
Operations.Create);
if (!isAuthorized.Succeeded)
{
return(Forbid());
}
CreateChatMessage chatMessage = new CreateChatMessage
{
User = user,
Message = chatMessageDTO.Message,
ChatGroupUuid = chatMessageDTO.ChatGroupUuid
};
ChatMessageResponse createRes = await _chatMessageService.CreateChatMessageAsync(chatMessage);
// Broadcast message to only clients who are members of the chat group
await _chatHubContext.Clients.Group(chatMessageDTO.ChatGroupUuid.ToString()).SendAsync("ReceiveMessage", createRes);
return(createRes);
}
public async Task <APIGatewayProxyResponse> SendMessageHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
try
{
// Construct the API Gateway endpoint that incoming message will be broadcasted to.
var domainName = request.RequestContext.DomainName;
var stage = request.RequestContext.Stage;
var endpoint = $"https://{domainName}/{stage}";
var connectionId = request.RequestContext.ConnectionId;
context.Logger.LogLine($"API Gateway management endpoint: {endpoint}");
JsonDocument message = JsonDocument.Parse(request.Body);
// Grab the data from the JSON body which is the message to broadcasted.
JsonElement dataProperty;
if (!message.RootElement.TryGetProperty("data", out dataProperty))
{
context.Logger.LogLine("Failed to find data element in JSON document");
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.BadRequest
});
}
var options = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
};
ChatMessageRequest messageRequest = JsonSerializer.Deserialize <ChatMessageRequest>(dataProperty.ToString(), options);
string date = (DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds.ToString();
await DDBUtils.PutMessage(messageRequest.Message, messageRequest.RoomID, messageRequest.UserID, date);
ChatMessageResponse chatMsg = new ChatMessageResponse
{
Success = true,
Message = messageRequest.Message,
Date = date,
Author = messageRequest.UserID,
RoomId = messageRequest.RoomID
};
string data = JsonSerializer.Serialize(chatMsg);
var stream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(data));
var queryRequest = new QueryRequest
{
TableName = RoomsConnectionsTable,
KeyConditionExpression = "RoomId = :ri",
ExpressionAttributeValues = new Dictionary <string, AttributeValue> {
{ ":ri", new AttributeValue {
S = messageRequest.RoomID
} }
},
ProjectionExpression = "RoomId, ConnectionId"
};
var queryResponse = await DDBClient.QueryAsync(queryRequest);
// Construct the IAmazonApiGatewayManagementApi which will be used to send the message to.
var apiClient = ApiGatewayManagementApiClientFactory(endpoint);
// Loop through all of the connections and broadcast the message out to the connections.
var count = 0;
foreach (var item in queryResponse.Items)
{
var postConnectionRequest = new PostToConnectionRequest
{
ConnectionId = item["ConnectionId"].S,
Data = stream
};
try
{
context.Logger.LogLine($"Post to connection {count}: {postConnectionRequest.ConnectionId}");
stream.Position = 0;
await apiClient.PostToConnectionAsync(postConnectionRequest);
count++;
}
catch (AmazonServiceException e)
{
// API Gateway returns a status of 410 GONE then the connection is no
// longer available. If this happens, delete the identifier
// from our DynamoDB table.
if (e.StatusCode == HttpStatusCode.Gone)
{
var ddbDeleteRequest = new DeleteItemRequest
{
TableName = RoomsConnectionsTable,
Key = new Dictionary <string, AttributeValue>
{
{ "RoomId", new AttributeValue {
S = item["RoomId"].S
} },
{ "ConnectionId", new AttributeValue {
S = postConnectionRequest.ConnectionId
} }
}
};
context.Logger.LogLine($"Deleting gone connection: {postConnectionRequest.ConnectionId}");
await DDBClient.DeleteItemAsync(ddbDeleteRequest);
}
else
{
context.Logger.LogLine($"Error posting message to {postConnectionRequest.ConnectionId}: {e.Message}");
context.Logger.LogLine(e.StackTrace);
}
}
}
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = "Data sent to " + count + " connection" + (count == 1 ? "" : "s")
});
}
catch (Exception e)
{
context.Logger.LogLine("Error sending message: " + e.Message);
context.Logger.LogLine(e.StackTrace);
return(new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Body = $"Failed to send message: {e.Message}"
});
}
}
public async Task SendMessage(ChatMessageResponse chatMessageResponse)
{
Guid chatGroupUuid = chatMessageResponse.ChatMessageDTO.ChatGroupUuid;
await Clients.Group(chatGroupUuid.ToString()).SendAsync("ReceiveMessage", chatMessageResponse);
}
void IChatHubReceiver.OnSendMessage(ChatMessageResponse message) => OnSendMessageEvent?.Invoke(message);
private void ChatHub_OnSendMessage(ChatMessageResponse message) => messagelog += $"{message.UserName} : {message.Message}\n";
