public override async Task Execute(CommandServicesContext context, CommandCallerContext callerContext, string[] args, ChatHubUser caller)
{
if (args.Length == 0)
{
await context.ChatHub.SendClientNotification("No arguments found.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);
return;
}
args.Reverse();
for (int i = 0; i < args.Length; i++)
{
args[i] = args[i].Reverse();
}
string msg = String.Join(" ", args).Trim();
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = callerContext.RoomId,
ChatHubUserId = caller.UserId,
User = caller,
Content = msg,
Type = ChatHubMessageType.Guest.ToString()
};
context.ChatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = context.ChatHubService.CreateChatHubMessageClientModel(chatHubMessage);
var connectionsIds = context.ChatHubService.GetAllExceptConnectionIds(caller);
await context.ChatHub.Clients.GroupExcept(callerContext.RoomId.ToString(), connectionsIds).SendAsync("AddMessage", chatHubMessageClientModel);
}
public async Task SendCommandMetaDatas(int roomId)
{
ChatHubUser user = await this.GetChatHubUserAsync();
List <string> callerUserRoles = new List <string>()
{
RoleNames.Everyone
};
if (Context.User.HasClaim(ClaimTypes.Role, RoleNames.Admin))
{
callerUserRoles.Add(RoleNames.Admin);
}
List <ChatHubCommandMetaData> commandMetaDatas = CommandManager.GetCommandsMetaDataByUserRole(callerUserRoles.ToArray()).ToList();
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = roomId,
ChatHubUserId = user.UserId,
User = user,
Content = string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), ChatHubMessageType.Commands),
CommandMetaDatas = commandMetaDatas
};
this.chatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
await Clients.Clients(user.Connections.Active().Select(c => c.ConnectionId).ToArray <string>()).SendAsync("AddMessage", chatHubMessageClientModel);
}
public void AddMessage(ChatHubMessage message, ChatHubRoom room)
{
if (!room.Messages.Any(x => x.Id == message.Id))
{
room.Messages.Add(message);
}
}
public static void AddMessage(this ChatHubRoom room, ChatHubMessage message)
{
if (!room.Messages.Any(x => x.Id == message.Id))
{
room.Messages.Add(message);
}
}
public async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
ChatHubRoom room = this.Rooms.FirstOrDefault(item => item.Id == message.ChatHubRoomId);
this.AddMessage(message, room);
this.UpdateUI();
}
private async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
if (message.ChatHubRoomId.ToString() != ChatHubService.ContextRoomId)
{
ChatHubService.Rooms.FirstOrDefault(room => room.Id == message.ChatHubRoomId).UnreadMessages++;
this.UpdateUIStateHasChanged();
}
}
private async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
if (message.ChatHubRoomId.ToString() != ChatHubService.ContextRoomId)
{
ChatHubService.Rooms.FirstOrDefault(room => room.Id == message.ChatHubRoomId).UnreadMessages++;
this.UpdateUIStateHasChanged();
}
string elementId = string.Concat("#message-window-", ModuleState.ModuleId.ToString(), "-", message.ChatHubRoomId.ToString());
int animationTime = 1000;
await this.ScrollService.ScrollToBottom(elementId, animationTime);
}
public ChatHubMessage AddChatHubMessage(ChatHubMessage ChatHubMessage)
{
try
{
db.ChatHubMessage.Add(ChatHubMessage);
db.SaveChanges();
return(ChatHubMessage);
}
catch
{
throw;
}
}
public ChatHubMessage UpdateChatHubMessage(ChatHubMessage ChatHubMessage)
{
try
{
db.Entry(ChatHubMessage).State = EntityState.Modified;
db.SaveChanges();
return(ChatHubMessage);
}
catch
{
throw;
}
}
private async Task Client_OnMessageReceivedAsync(object sender, OnMessageReceivedArgs e)
{
IEnumerable <IChatService> chatServices = _serviceProvider.GetServices <IChatService>();
string botResponse = string.Empty;
foreach (IChatService chatService in chatServices)
{
botResponse = await chatService.ProcessMessageAsync(e.ChatMessage);
if (!string.IsNullOrEmpty(botResponse))
{
break;
}
}
StreamUserModel chatUser = _knownUsers.FirstOrDefault(f => f.Id.Equals(e.ChatMessage.UserId, StringComparison.CurrentCultureIgnoreCase));
if (chatUser == null)
{
chatUser = await _streamAnalytics.GetUserAsync(e.ChatMessage.UserId);
AddKnownUser(chatUser);
}
ChatHubMessage chatHubMessage = ChatHubMessage.FromChatMessage(e.ChatMessage, chatUser);
if (!string.IsNullOrEmpty(chatHubMessage.HubMessage.Trim()))
{
await BroadcastChatMessage(chatHubMessage);
if (!string.IsNullOrEmpty(botResponse))
{
ChatHubMessage botChatHubMessage = ChatHubMessage.FromBot(botResponse);
await BroadcastChatMessage(botChatHubMessage);
}
EmoteSet emoteSet = e.ChatMessage.EmoteSet;
if (emoteSet != null && emoteSet.Emotes.Count > 0)
{
List <EmoteSet.Emote> emotes = emoteSet.Emotes;
foreach (EmoteSet.Emote emote in emotes)
{
await BroadcastEmote(emote.ImageUrl);
await Task.Delay(new Random().Next(500, 1200));
}
}
}
}
public void DeleteChatHubMessage(int ChatHubMessageId, int ChatHubRoomId)
{
try
{
ChatHubMessage ChatHubMessage = db.ChatHubMessage.Where(item => item.Id == ChatHubMessageId)
.Where(item => item.ChatHubRoomId == ChatHubRoomId).FirstOrDefault();
db.ChatHubMessage.Remove(ChatHubMessage);
db.SaveChanges();
}
catch
{
throw;
}
}
public async Task SendClientNotification(string message, int roomId, string connectionId, ChatHubUser targetUser, ChatHubMessageType chatHubMessageType)
{
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = roomId,
ChatHubUserId = targetUser.UserId,
User = targetUser,
Content = message ?? string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), chatHubMessageType)
};
this.chatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
await Clients.Client(connectionId).SendAsync("AddMessage", chatHubMessageClientModel);
}
public async void OnAddChatHubMessageExecute(object sender, ChatHubMessage message)
{
ChatHubRoom room = this.Rooms.FirstOrDefault(item => item.Id == message.ChatHubRoomId);
room.AddMessage(message);
if (message.ChatHubRoomId.ToString() != this.ContextRoomId)
{
this.Rooms.FirstOrDefault(room => room.Id == message.ChatHubRoomId).UnreadMessages++;
}
this.RunUpdateUI();
string elementId = string.Concat("#message-window-", this.ModuleId.ToString(), "-", message.ChatHubRoomId.ToString());
await this.ScrollService.ScrollToBottom(elementId);
}
public async Task SendGroupNotification(string message, int roomId, string connectionId, ChatHubUser contextUser, ChatHubMessageType chatHubMessageType)
{
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = roomId,
ChatHubUserId = contextUser.UserId,
User = contextUser,
Content = message ?? string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), chatHubMessageType)
};
this.chatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
var connectionsIds = this.chatHubService.GetAllExceptConnectionIds(contextUser);
await Clients.GroupExcept(roomId.ToString(), connectionsIds).SendAsync("AddMessage", chatHubMessageClientModel);
}
public async Task <ChatHubMessageDto> Add(string msgContent, string applicationUserId)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var context = scope.ServiceProvider.GetService <MinesweeperDbContext>();
var message = new ChatHubMessage()
{
ApplicationUserId = applicationUserId,
Content = msgContent,
Date = DateTime.UtcNow,
};
context.ChatHubMessages.Add(message);
await context.SaveChangesAsync();
await context.Entry(message).Reference(msg => msg.ApplicationUser).LoadAsync();
return(_mapper.Map <ChatHubMessage, ChatHubMessageDto>(message));
}
}
public ChatHubMessage CreateChatHubMessageClientModel(ChatHubMessage message)
{
List <ChatHubPhoto> photos = message.Photos != null && message.Photos.Any() ? message.Photos.Select(item => CreateChatHubPhotoClientModel(item)).ToList() : null;
ChatHubUser user = message.User != null?this.CreateChatHubUserClientModel(message.User) : null;
return(new ChatHubMessage()
{
Id = message.Id,
ChatHubRoomId = message.ChatHubRoomId,
ChatHubUserId = message.ChatHubUserId,
User = user,
Content = message.Content,
Type = message.Type,
Photos = photos,
CommandMetaDatas = message.CommandMetaDatas,
CreatedOn = message.CreatedOn,
CreatedBy = message.CreatedBy,
ModifiedOn = message.ModifiedOn,
ModifiedBy = message.ModifiedBy
});
}
public async Task SendCommandMetaDatas(int roomId)
{
ChatHubUser user = await this.GetChatHubUserAsync();
var callerUserRole = Constants.AllUsersRole;
List <ChatHubCommandMetaData> commandMetaDatas = CommandManager.GetCommandsMetaDataByUserRole(callerUserRole).ToList();
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = roomId,
ChatHubUserId = user.UserId,
User = user,
Content = string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), ChatHubMessageType.Commands),
CommandMetaDatas = commandMetaDatas
};
this.chatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
await Clients.Clients(user.Connections.Active().Select(c => c.ConnectionId).ToArray <string>()).SendAsync("AddMessage", chatHubMessageClientModel);
}
private async void Client_OnMessageReceivedAsync(object sender, OnMessageReceivedArgs e)
{
IEnumerable <IChatService> chatServices = serviceProvider.GetServices <IChatService>();
string botResponse = string.Empty;
foreach (IChatService chatService in chatServices)
{
botResponse = await chatService.ProcessMessageAsync(e.ChatMessage);
if (!string.IsNullOrEmpty(botResponse))
{
break;
}
}
await _overlayHubContext.Clients.All.SendAsync("ReceiveNewChatMessage", new ChatHubMessage(e.ChatMessage));
if (!string.IsNullOrEmpty(botResponse))
{
ChatHubMessage chatHubMessage = new ChatHubMessage(botResponse);
await _overlayHubContext.Clients.All.SendAsync("ReceiveNewChatMessage", chatHubMessage);
}
EmoteSet emoteSet = e.ChatMessage.EmoteSet;
if (emoteSet != null && emoteSet.Emotes.Count > 0)
{
List <EmoteSet.Emote> emotes = emoteSet.Emotes;
foreach (EmoteSet.Emote emote in emotes)
{
await _overlayHubContext.Clients.All.SendAsync("ReceiveNewEmoji", emote.ImageUrl);
await Task.Delay(500);
}
}
}
public async Task SendMessage(string message, int roomId, int moduleId)
{
ChatHubUser user = await this.GetChatHubUserAsync();
if (await ExecuteCommandManager(user, message, roomId))
{
return;
}
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = roomId,
ChatHubUserId = user.UserId,
User = user,
Content = message ?? string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), ChatHubMessageType.Guest)
};
this.chatHubRepository.AddChatHubMessage(chatHubMessage);
ChatHubMessage chatHubMessageClientModel = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
var connectionsIds = this.chatHubService.GetAllExceptConnectionIds(user);
await Clients.GroupExcept(roomId.ToString(), connectionsIds).SendAsync("AddMessage", chatHubMessageClientModel);
}
/// <summary>
/// Broadcasts the provided chat message to clients of the hub
/// </summary>
/// <param name="chatHubMessage">Message received from Twitch IRC chat</param>
private async Task BroadcastChatMessage(ChatHubMessage chatHubMessage)
{
await _chatHubConnection.InvokeAsync("BroadcastChatMessage", chatHubMessage);
}
/// <summary>
/// Broadcasts the provided chat message to clients of the hub
/// </summary>
/// <param name="chatHubMessage">Message received from Twitch IRC chat</param>
public async Task BroadcastChatMessage(ChatHubMessage chatHubMessage)
{
await Clients.All.ReceiveChatMessage(chatHubMessage);
}
public void OpenDialog(ChatHubMessage item)
{
this.Message = item;
this.DialogIsOpen = true;
StateHasChanged();
}
public override async Task Execute(CommandServicesContext context, CommandCallerContext callerContext, string[] args, ChatHubUser caller)
{
if (args.Length == 0)
{
await context.ChatHub.SendClientNotification("No arguments found.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);
return;
}
string targetUserName = args[0];
ChatHubUser targetUser = await context.ChatHubRepository.GetUserByDisplayName(targetUserName);
targetUser = targetUser == null ? await context.ChatHubRepository.GetUserByUserNameAsync(targetUserName) : targetUser;
if (targetUser == null)
{
await context.ChatHub.SendClientNotification("No user found.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);
return;
}
if (!targetUser.Online())
{
await context.ChatHub.SendClientNotification("User not online.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);
return;
}
if (caller.UserId == targetUser.UserId)
{
await context.ChatHub.SendClientNotification("Calling user can not be target user.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);
return;
}
string msg = null;
if (args.Length > 1)
{
msg = String.Join(" ", args.Skip(1)).Trim();
}
var callerRoom = context.ChatHubRepository.GetChatHubRoom(callerContext.RoomId);
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = callerContext.RoomId,
ChatHubUserId = caller.UserId,
User = caller,
Content = msg ?? string.Empty,
Type = Enum.GetName(typeof(ChatHubMessageType), ChatHubMessageType.Whisper)
};
context.ChatHubRepository.AddChatHubMessage(chatHubMessage);
var chatHubMessageClientModel = context.ChatHubService.CreateChatHubMessageClientModel(chatHubMessage);
var users = new List <ChatHubUser>(); users.Add(caller); users.Add(targetUser);
foreach (var item in users)
{
var rooms = context.ChatHubRepository.GetChatHubRoomsByUser(item).Public().Active().ToList();
var connections = item.Connections.Active();
foreach (var room in rooms)
{
foreach (var connection in connections)
{
await context.ChatHub.Clients.Client(connection.ConnectionId).SendAsync("AddMessage", chatHubMessageClientModel);
}
}
}
}
public async Task <IActionResult> PostImageUpload()
{
string connectionId = null;
if (Request.Headers.ContainsKey("connectionId"))
{
connectionId = Request.Headers["connectionId"];
if (string.IsNullOrEmpty(connectionId))
{
return(new BadRequestObjectResult(new { Message = "No connection id." }));
}
}
ChatHubUser user = await this.chatHubService.IdentifyGuest(connectionId);
if (user == null)
{
return(new BadRequestObjectResult(new { Message = "No user found." }));
}
string displayName = string.Empty;
if (Request.Headers.ContainsKey("displayName"))
{
displayName = Request.Headers["displayName"];
if (string.IsNullOrEmpty(displayName))
{
return(new BadRequestObjectResult(new { Message = "No display name." }));
}
}
string roomId = string.Empty;
if (Request.Headers.ContainsKey("roomId"))
{
roomId = Request.Headers["roomId"];
if (string.IsNullOrEmpty(roomId))
{
return(new BadRequestObjectResult(new { Message = "No room id." }));
}
}
string moduleId = string.Empty;
if (Request.Headers.ContainsKey("moduleId"))
{
moduleId = Request.Headers["moduleId"];
if (string.IsNullOrEmpty(moduleId))
{
return(new BadRequestObjectResult(new { Message = "No module id." }));
}
}
IFormFileCollection files = Request.Form.Files;
if (files == null || files.Count <= 0)
{
return(new BadRequestObjectResult(new { Message = "No files." }));
}
string content = string.Concat(files.Count, " ", "Photo(s)");
ChatHubRoom chatHubRoom = this.chatHubRepository.GetChatHubRoom(Int32.Parse(roomId));
if (chatHubRoom == null)
{
return(new BadRequestObjectResult(new { Message = "No room found." }));
}
ChatHubMessage chatHubMessage = new ChatHubMessage()
{
ChatHubRoomId = chatHubRoom.Id,
ChatHubUserId = user.UserId,
Type = Enum.GetName(typeof(ChatHubMessageType), ChatHubMessageType.Image),
Content = content,
User = user
};
chatHubMessage = this.chatHubRepository.AddChatHubMessage(chatHubMessage);
try
{
var maxFileSize = 10;
var maxFileCount = 3;
string folderName = "modules/oqtane.chathubs/images/selfies";
string webRootPath = string.Concat(this.webHostEnvironment.ContentRootPath, "\\wwwroot");
string newPath = Path.Combine(webRootPath, folderName);
if (!Directory.Exists(newPath))
{
Directory.CreateDirectory(newPath);
}
if (files.Count > maxFileCount)
{
return(new BadRequestObjectResult(new { Message = "Maximum number of files exceeded." }));
}
foreach (IFormFile file in files)
{
if (file.Length > (maxFileSize * 1024 * 1024))
{
return(new BadRequestObjectResult(new { Message = "File size Should Be UpTo " + maxFileSize + "MB" }));
}
var supportedFileExtensions = new[] { ".jpg", ".jpeg", ".png", ".gif" };
string fileExtension = Path.GetExtension(file.FileName);
if (!supportedFileExtensions.Contains(fileExtension))
{
return(new BadRequestObjectResult(new { Message = "Unknown file type(s)." }));
}
/*
* ObjectResult result = await this.PostAsync(file);
* dynamic obj = result.Value;
* string imageClassification = string.Empty;
* if (result.StatusCode.Value == 200)
* {
* if (obj.predictedLabel == "dickpic")
* {
* var percent = string.Format("{0:P2}", Math.Round((float)obj.probability, 3));
* if ((float)obj.probability >= 0.99)
* {
* imageClassification = string.Concat(" | ", "(", "most likely identified as ", obj.predictedLabel, ": ", percent, ")");
* }
* }
* }
*/
int imageWidth, imageHeight;
string fileName = string.Concat(Guid.NewGuid().ToString(), fileExtension);
string fullPath = Path.Combine(newPath, fileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
file.CopyTo(stream);
FileInfo fileInfo = new FileInfo(file.FileName);
var sizeInBytes = file.Length;
Bitmap img = new Bitmap(stream);
imageWidth = img.Width;
imageHeight = img.Height;
}
ChatHubPhoto chatHubPhoto = new ChatHubPhoto()
{
ChatHubMessageId = chatHubMessage.Id,
Source = fileName,
Size = file.Length,
Thumb = fileName,
Caption = string.Concat(user.DisplayName, " | ", Math.Round(Convert.ToDecimal(file.Length / (1024.0m * 1024.0m)), 2), "MB" /*, imageClassification*/),
Message = chatHubMessage,
Width = imageWidth,
Height = imageHeight
};
chatHubPhoto = this.chatHubRepository.AddChatHubPhoto(chatHubPhoto);
}
chatHubMessage = this.chatHubService.CreateChatHubMessageClientModel(chatHubMessage);
await this.chatHub.Clients.Group(chatHubMessage.ChatHubRoomId.ToString()).SendAsync("AddMessage", chatHubMessage);
return(new OkObjectResult(new { Message = "Successfully Uploaded Files." }));
}
catch (Exception ex)
{
return(new BadRequestObjectResult(new { Message = "Error Uploading Files." }));
}
}
