private Task InsertMessageAsync(SignalRTransportType obj, long?userId, string group, CancellationToken token)
{
var queueClient = _queueClients.GetOrAdd(QueueSignalr, x => new QueueClient(_connectionString, x));
var jsonSerializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
jsonSerializerSettings.Converters.Add(new StringEnumConverter {
CamelCaseText = true
});
var json = JsonConvert.SerializeObject(obj, jsonSerializerSettings);
token.ThrowIfCancellationRequested();
return(queueClient.SendAsync(new Message
{
Body = Encoding.UTF8.GetBytes(json),
UserProperties =
{
["userId"] = userId,
["group"] = group
},
ContentType = "application/json",
}));
}
private async Task ChangeOnlineStatus(long currentUserId, bool isOnline)
{
try
{
if (_canUpdateDb)
{
const string sql = @"update sb.[user] set Online = @IsOnline, LastOnline = GETUTCDATE() where Id = @Id";
using (var connection = _dapper.OpenConnection())
{
await connection.ExecuteAsync(sql, new { Id = currentUserId, IsOnline = isOnline });
}
}
}
catch (Exception e)
{
_logger.Value.TrackException(e, new Dictionary <string, string>()
{
["SignalR"] = "Signalr",
["currentUserId"] = "currentUserId"
});
_canUpdateDb = false;
}
var message = new SignalRTransportType(SignalRType.User, SignalREventAction.OnlineStatus,
new
{
id = currentUserId,
online = true
});
await Clients.All.SendAsync(MethodName, message);
}
public Task HandleAsync(UserSuspendEvent eventMessage, CancellationToken token)
{
var message = new SignalRTransportType(SignalRType.User,
SignalRAction.Update, new { locakOutEnd = DateTime.MaxValue });
return(_queueProvider.InsertMessageAsync
(message, eventMessage.User.Id, token));
}
//public async Task HandleAsync(QuestionCreatedEvent eventMessage, CancellationToken token)
//{
// var dto = new QuestionFeedDto
// {
// Id = eventMessage.Question.Id,
// // ReSharper disable once ConstantConditionalAccessQualifier this is later stuff - we still have null courses
// Course = eventMessage.Question.Course?.Id,
// Text = eventMessage.Question.Text,
// Answers = 0,
// DateTime = DateTime.UtcNow,
// User = new QuestionUserDto()
// {
// Id = eventMessage.Question.User.Id,
// Name = eventMessage.Question.User.Name,
// Image = eventMessage.Question.User.Image
// }
// // UserId = eventMessage.Question.User.Id
// };
// await _queueProvider.InsertMessageAsync(
// new SignalRTransportType(SignalRType.Question, SignalRAction.Add, dto), $"country_{eventMessage.Question.User.Country.ToLowerInvariant()}", token);
//}
//public async Task HandleAsync(QuestionDeletedEvent eventMessage, CancellationToken token)
//{
// var dto = new
// {
// id = eventMessage.Question.Id
// };
// await _queueProvider.InsertMessageAsync(
// new SignalRTransportType(SignalRType.Question, SignalRAction.Delete, dto), token);
//}
//public Task HandleAsync(AnswerCreatedEvent eventMessage, CancellationToken token)
//{
// var user = new UserDto(eventMessage.Answer.User.Id, eventMessage.Answer.User.Name,
// eventMessage.Answer.User.Transactions.Score, eventMessage.Answer.User.Image);
// var answerDto = new QuestionDetailAnswerDto
// (
// eventMessage.Answer.Id,
// eventMessage.Answer.Text,
// user,
// eventMessage.Answer.Created
// );
// var dto = new
// {
// QuestionId = eventMessage.Answer.Question.Id,
// Answer = answerDto
// };
// return _queueProvider.InsertMessageAsync(new SignalRTransportType(SignalRType.Answer, SignalRAction.Add, dto), token);
//}
//public Task HandleAsync(AnswerDeletedEvent eventMessage, CancellationToken token)
//{
// var dto = new
// {
// questionId = eventMessage.Answer.Question.Id,
// answer = new { id = eventMessage.Answer.Id }
// };
// return _queueProvider.InsertMessageAsync(new SignalRTransportType(SignalRType.Answer, SignalRAction.Delete, dto), token);
//}
public Task HandleAsync(TransactionEvent eventMessage, CancellationToken token)
{
var message = new SignalRTransportType(SignalRType.User,
SignalRAction.Update, new { balance = eventMessage.User.Transactions.Balance });
return(_queueProvider.InsertMessageAsync
(message, eventMessage.User.Id, token));
}
public async Task HandleAsync(StudyRoomOnlineChangeEvent eventMessage, CancellationToken token)
{
var studyUser = eventMessage.StudyUser;
var studyRoom = studyUser.Room;
var onlineCount = studyRoom.Users.Count(f => f.Online);
var totalOnline = 2; // //studyRoom.Users.Count;
_telemetryClient.TrackEvent($"Users in room {studyRoom.Id}", metrics: new Dictionary <string, double>()
{
["onlineCount"] = onlineCount,
["totalOnline"] = totalOnline
});
if (onlineCount == totalOnline)
{
var session = studyRoom.GetCurrentSession();
if (session != null)
{
var roomExists = await _videoProvider.GetRoomAvailableAsync(session.SessionId);
if (roomExists)
{
foreach (var user in studyRoom.Users)
{
var jwtToken =
await _videoProvider.ConnectToRoomAsync(session.SessionId, user.User.Id.ToString());
var message2 = new SignalRTransportType(SignalRType.StudyRoom,
SignalRAction.Update, new
{
jwtToken
});
await _hubContext.Clients.User(user.User.Id.ToString())
.SendAsync(SbHub.MethodName, message2, token);
}
return;
}
}
}
var message = new SignalRTransportType(SignalRType.StudyRoom,
SignalRAction.Update, new
{
onlineCount,
totalOnline,
users = studyRoom.Users.Where(f => f.Online).Select(s => s.User.Id).ToArray(),
allUsers = studyRoom.Users.Select(s => s.User.Id).ToArray()
});
await _hubContext.Clients.Group(studyRoom.Id.ToString()).SendAsync(SbHub.MethodName, message, token);
}
public async Task HandleAsync(ChatReadEvent eventMessage, CancellationToken token)
{
var chatUser = eventMessage.ChatUser;
var users = chatUser.ChatRoom.Users.Where(w => w.User.Id != chatUser.User.Id).Select(s => s.User.Id.ToString()).ToList();
var message = new SignalRTransportType(SignalRType.Chat,
SignalRAction.Update, new
{
conversationId = chatUser.ChatRoom.Identifier
});
await _hubContext.Clients.Users(users).SendAsync(SbHub.MethodName, message, token);
}
public async Task HandleAsync(StudyRoomCreatedEvent eventMessage, CancellationToken token)
{
var studyRoom = eventMessage.StudyRoom;
var message = new SignalRTransportType(SignalRType.StudyRoom,
SignalRAction.Add, new
{
id = studyRoom.Id,
userId = studyRoom.Tutor.Id,
conversationId = studyRoom.Identifier
});
await _hubContext.Clients.Users(studyRoom.Users.Select(s => s.User.Id.ToString()).ToList()).SendAsync(SbHub.MethodName, message, token);
}
public async Task HandleAsync(ChatMessageEvent eventMessage, CancellationToken token)
{
var chatMessage = eventMessage.ChatMessage;
var message = new SignalRTransportType(SignalRType.Chat,
SignalRAction.Add, new
{
conversationId = chatMessage.ChatRoom.Identifier,
message = BuildChatMessage((dynamic)chatMessage)
});
List <string> users = BuildUserList((dynamic)chatMessage);
await _hubContext.Clients.Users(users).SendAsync(SbHub.MethodName, message, token);
}
public async Task HandleAsync(StudentPaymentReceivedEvent eventMessage, CancellationToken token)
{
var list = new List <Task>();
var message = new SignalRTransportType(SignalRType.User,
SignalREventAction.PaymentReceived, new object());
foreach (var roomId in eventMessage.User.StudyRooms.Select(s => s.Room.Id))
{
var t = _studyRoomHubContext.Clients.Group(roomId.ToString()).SendAsync(SbHub.MethodName, message, token);
list.Add(t);
}
var t1 = _hubContext.Clients.User(eventMessage.User.Id.ToString())
.SendAsync(SbHub.MethodName, message, token);
list.Add(t1);
await Task.WhenAll(list);
}
public async Task HandleAsync(ChatMessageEvent eventMessage, CancellationToken token)
{
var chatMessage = eventMessage.ChatMessage;
if (chatMessage is ChatTextMessage chatTextMessage)
{
var message = new SignalRTransportType(SignalRType.Chat,
SignalRAction.Add, new
{
conversationId = chatMessage.ChatRoom.Identifier,
message = BuildChatMessage(chatTextMessage)
});
var users = BuildUserList(chatTextMessage);
foreach (var user in users)
{
await _queueProvider.InsertMessageAsync(message, user, token);
}
}
}
private async Task DoProcessAsync(StudyRoomSession studyRoomSession, CancellationToken token)
{
var users = studyRoomSession.StudyRoom.Users;
var session = studyRoomSession.SessionId;
var tasks = new List <Task>();
foreach (var user in users)
{
var jwtToken = await _videoProvider.ConnectToRoomAsync(session, user.User.Id.ToString());
var message = new SignalRTransportType(SignalRType.StudyRoom,
SignalREventAction.StartSession, new
{
jwtToken
});
var t = _hubContext.Clients.User(user.User.Id.ToString()).SendAsync(SbHub.MethodName, message, token);
tasks.Add(t);
}
await Task.WhenAll(tasks);
}
public async Task <IActionResult> LogOutAsync(
[FromServices] SignInManager <User> signInManager,
[FromServices] IHubContext <SbHub> hubContext, CancellationToken token)
{
if (!User.Identity.IsAuthenticated)
{
return(Redirect("/"));
}
var message = new SignalRTransportType(SignalRType.User, SignalREventAction.Logout,
new object());
await hubContext.Clients.User(signInManager.UserManager.GetUserId(User)).SendCoreAsync("Message", new object[]
{
message
}, token);
await signInManager.SignOutAsync();
TempData.Clear();
return(Redirect("/"));
}
public async Task HandleAsync(StudyRoomOnlineChangeEvent eventMessage, CancellationToken token)
{
var studyUser = eventMessage.StudyUser;
if (!studyUser.Online)
{
return;
}
var studyRoom = studyUser.Room;
var otherUsers = studyRoom.Users.Select(s => s.User.Id)
.Where(w => w != studyUser.User.Id).ToList();
var message = new SignalRTransportType(SignalRType.User,
SignalREventAction.EnterStudyRoom, new
{
userName = studyUser.User.Name,
studyRoomId = studyRoom.Id
});
await _hubContextSpitball.Clients.Users(otherUsers.Select(s => s.ToString()).ToList())
.SendAsync(SbHub.MethodName, message, CancellationToken.None);
}
public Task InsertMessageAsync(SignalRTransportType obj, long?userId, CancellationToken token)
{
return(InsertMessageAsync(obj, userId, null, token));
}
public Task InsertMessageAsync(SignalRTransportType obj, string groupId, CancellationToken token)
{
return(InsertMessageAsync(obj, null, groupId, token));
}
