private async Task ThrowIfEncryptionForbiddenAsync(long senderId, long receiverId)
{
if (NodeSettings.Configs.Node.EncryptionType == EncryptionType.TotallyForbidden)
{
throw new EncryptionForbiddenException("Encryption is forbidden by the node settings.");
}
var receiver = await _loadUsersService.GetUserAsync(receiverId).ConfigureAwait(false);
var sender = await _loadUsersService.GetUserAsync(senderId).ConfigureAwait(false);
if (receiver == null || sender == null)
{
return;
}
if (receiver.NodeId != sender.NodeId)
{
var receiverNode = _connectionsService.GetNodeConnection(receiver.NodeId.Value);
if (receiverNode == null)
{
return;
}
if (receiverNode.Node.EncryptionType == EncryptionType.TotallyForbidden)
{
throw new EncryptionForbiddenException("Encryption is forbidden by the receiver node settings.");
}
}
else
{
if (NodeSettings.Configs.Node.EncryptionType == EncryptionType.NodeUsersForbidden)
{
throw new EncryptionForbiddenException("Encryption is forbidden by the node settings.");
}
}
}
public async Task DeleteUser()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
await deleteUsersService.DeleteUserAsync(user.Id);
Assert.Null(await loadUsersService.GetUserAsync(user.Id));
}
public async Task HandleAsync()
{
NodeResponse response = default;
try
{
TokenVm token = await tokensService.CheckTokenAsync(request.Token, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
UserVm user = await loadUsersService.GetUserAsync(token.UserId).ConfigureAwait(false);
response = new UserTokensNodeResponse(request.RequestId, token, user);
}
catch (InvalidTokenException)
{
response = new ResultNodeResponse(request.RequestId, ErrorCode.InvalidAccessToken);
}
catch (TokensTimeoutException)
{
response = new ResultNodeResponse(request.RequestId, ErrorCode.AccessTokenTimeout);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
response = new ResultNodeResponse(request.RequestId, ErrorCode.UnknownError);
}
finally
{
NodeWebSocketCommunicationManager.SendResponse(response, current);
}
}
public async Task GetUser()
{
var expectedUser = fillTestDbHelper.Users.FirstOrDefault();
var actualUser = await loadUsersService.GetUserAsync(expectedUser.Id);
Assert.Equal(expectedUser.Tag, actualUser.Tag);
}
public async Task EditUserNode()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
await updateUsersService.EditUserNodeAsync(user.Id, 2);
var actualUser = await loadUsersService.GetUserAsync(user.Id);
Assert.Equal(2, actualUser.NodeId);
}
public async Task <IActionResult> SendToEmail([FromForm] SendQRModel model)
{
Dictionary <string, string> errors = new Dictionary <string, string>();
if (string.IsNullOrWhiteSpace(model.Email))
{
var user = await _loadUsersService.GetUserAsync(model.UserId).ConfigureAwait(false);
if (user == null)
{
errors.Add("userId", $"The user with the specified identifier was not found. ({nameof(model.UserId)} : {model.UserId})");
}
else
{
string userEmail = user.Emails?.FirstOrDefault();
if (string.IsNullOrWhiteSpace(userEmail))
{
errors.Add("email", $"The email address is not specified in the request parameters and the user does not have an email address. ({nameof(model.UserId)} : {model.UserId})");
}
model.Email = userEmail;
}
}
else
{
if (!ValidationHelper.IsEmailValid(model.Email))
{
errors.Add("email", $"The specified value is not a valid email address. ({nameof(model.Email)} : {model.Email})");
}
}
if (errors.Any())
{
return(new JsonResult(errors));
}
if (!string.IsNullOrWhiteSpace(model.UploadFileId))
{
await EmailHandler.SendEmailWithFileAsync(model.Email, await _fileStorage.GetStreamAsync(model.UploadFileId), model.UploadFileId, "QR-Code");
await _fileStorage.RemoveAsync(model.UploadFileId);
}
return(Ok());
}
public async Task HandleAsync()
{
var user = await loadUsersService.GetUserAsync(notice.UserId).ConfigureAwait(false);
if (user.NodeId != nodeConnection.Node.Id)
{
return;
}
if (notice.ConversationId != null && notice.ConversationType != null)
{
await deleteMessagesService.DeleteMessagesAsync(notice.ConversationId.Value, notice.ConversationType.Value, notice.UserId).ConfigureAwait(false);
}
else
{
await deleteMessagesService.DeleteMessagesAsync(notice.UserId).ConfigureAwait(false);
}
}
public async Task <Response> CreateResponseAsync()
{
try
{
string fileAccessToken = RandomExtensions.NextString(64);
var token = await qrCodesService.CreateTokenByQRCodeAsync(request.QR, request.DeviceTokenId, request.OSName, request.DeviceName, request.AppName).ConfigureAwait(false);
var user = await loadUsersService.GetUserAsync(token.UserId).ConfigureAwait(false);
clientConnection.UserId = user.Id;
clientConnection.FileAccessToken = fileAccessToken;
clientConnection.CurrentToken = token;
clientConnection.Confirmed = user.Confirmed;
clientConnection.CurrentDeviceTokenId = token.DeviceTokenId;
noticeService.SendNewSessionNoticeAsync(clientConnection);
return(new TokensResponse(request.RequestId, token, fileAccessToken, null, user));
}
catch (ObjectDoesNotExistsException ex)
{
return(new ResultResponse(request.RequestId, ex.Message, ObjectsLibrary.Enums.ErrorCode.ObjectDoesNotExists));
}
}
public async void NewMessageUpdateUserChatsAsync(MessageVm message)
{
try
{
UserVm senderInfo = await loadUsersService.GetUserAsync(message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
IEnumerable <long> usersId = await loadChatsService.GetChatUsersIdAsync(message.ConversationId.GetValueOrDefault()).ConfigureAwait(false);
foreach (long userId in usersId)
{
List <ConversationPreviewVm> cachedChats = (await GetUserChatsAsync(userId).ConfigureAwait(false))?.ToList();
if (cachedChats == null || cachedChats.All(opt => opt.ConversationId != message.ConversationId))
{
cachedChats = (await loadChatsService.GetUserChatPreviewAsync(userId, DateTime.UtcNow.ToUnixTime()).ConfigureAwait(false))?.ToList();
UpdateUserChats(userId, cachedChats);
continue;
}
ConversationPreviewVm updatedChat = cachedChats.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (updatedChat != null)
{
updatedChat.LastMessageSenderId = message.SenderId;
updatedChat.LastMessageTime = message.SendingTime;
updatedChat.LastMessageSenderName = senderInfo.NameFirst;
updatedChat.PreviewText = message.Text;
updatedChat.LastMessageId = message.GlobalId;
updatedChat.Read = false;
updatedChat.AttachmentType = (AttachmentType?)message.Attachments?.FirstOrDefault()?.Type ?? null;
UpdateUserChats(userId, cachedChats);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async void SendNewMessageNoticeToDialogUsers(IEnumerable <MessageDto> messages, ClientConnection senderClientConnection, long receiverId, bool saveMessageFlag = true)
{
try
{
long senderId = messages.FirstOrDefault().SenderId.GetValueOrDefault();
var dialogs = await loadDialogsService.GetUsersDialogsAsync(senderId, receiverId);
var currentDialog = dialogs.FirstOrDefault(dial => dial.FirstUserId == receiverId);
Notice senderNotice = default;
if (senderId != receiverId)
{
var message = messages.FirstOrDefault(mess => mess.ConversationId != currentDialog.Id);
senderNotice = new NewMessageNotice(
MessageConverter.GetMessageVm(message, senderId),
MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId));
}
else
{
var message = messages.FirstOrDefault();
senderNotice = new NewMessageNotice(
MessageConverter.GetMessageVm(message, senderId),
MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId));
}
var senderClients = connectionsService.GetUserClientConnections(messages.ElementAt(0).SenderId.GetValueOrDefault());
if (senderClients != null)
{
IEnumerable <ClientConnection> senderConnectionsExceptCurrent = senderClients.Where(connection => !Equals(senderClientConnection, connection));
await SendNoticeToClientsAsync(senderConnectionsExceptCurrent, senderNotice).ConfigureAwait(false);
}
if (messages.Count() == 2)
{
var message = messages.FirstOrDefault(mess => mess.ConversationId == currentDialog.Id);
var receiverClients = connectionsService.GetUserClientConnections(receiverId);
Notice receiverNotice = new NewMessageNotice(
MessageConverter.GetMessageVm(message, receiverId),
MarkdownHelper.ContainsMarkdownUserCalling(message.Text, receiverId));
if (receiverClients != null && receiverClients.Any())
{
await SendNoticeToClientsAsync(receiverClients, receiverNotice).ConfigureAwait(false);
}
else
{
var receiver = await loadUsersService.GetUserAsync(receiverId).ConfigureAwait(false);
if (receiver.NodeId == NodeSettings.Configs.Node.Id && !saveMessageFlag)
{
await pendingMessagesService.AddUserPendingMessageAsync(receiverId, receiverNotice, message.GlobalId).ConfigureAwait(false);
}
}
}
DialogDto dialog = await loadDialogsService.GetDialogAsync(currentDialog.Id).ConfigureAwait(false);
pushNotificationsService.SendMessageNotificationAsync(
messages.FirstOrDefault(opt => opt.ConversationId == currentDialog.Id),
new List <NotificationUser> {
new NotificationUser(dialog.FirstUserId, dialog.IsMuted)
});
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}