private async Task SendDataOperationAsync() { string errorMessage = null; for (var i = 0; i < PartCount; i++) { string messagePart = i < PartCount - 1 ? Message.Substring(i * MaxLength, MaxLength) : Message.Substring(i * MaxLength); var sendingDataResponse = await _holder.Connector.SendDataAsync(SenderAccount.AccountNumber, ReceiverAccount, _guid, SignerAccount?.AccountNumber, DataType.ChatMessage, (uint)i, i == 0?Amount : 0, Fee / PartCount, messagePart, SelectedEncryptionMethod.Method, Password); if (errorMessage == null) { errorMessage = sendingDataResponse.Error?.Message; } } if (errorMessage == null) { var manyMessagesText = PartCount > 1 ? $"consisting of {PartCount} parts " : ""; InfoMessage = new InfoMessageViewModel($"Message {manyMessagesText}sent successfully.", () => { SetDefaults(); InfoMessage = null; }); } else { InfoMessage = new InfoMessageViewModel(errorMessage, () => InfoMessage = null, true); } }
private async Task SendDataOperationAsync() { string errorMessage = null; for (var i = 0; i < PartCount; i++) { string messagePart = i < PartCount - 1 ? Message.Substring(i * MaxLength, MaxLength) : Message.Substring(i * MaxLength); var sendingDataResponse = await _connectorHolder.Connector.SendDataAsync(SenderAccount.AccountNumber, ReceiverAccount.AccountNumber, _guid, SignerAccount?.AccountNumber, DataType.ChatMessage, (uint)i, i == 0?Amount : 0, Fee / PartCount, messagePart, SelectedEncryptionMethod.Method, Password); if (errorMessage == null) { errorMessage = sendingDataResponse.Error?.Message; } } if (errorMessage == null) { _guid = Guid.NewGuid().ToString().ToUpper(); Message = null; await GetNewMessagesAsync(); } else { InfoMessage = new InfoMessageViewModel(errorMessage, () => InfoMessage = null, true); } }
public async Task InitializeAsync() { _isBusy = true; var errorInfo = new InfoMessageViewModel("Failed to load accounts! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); var keysResponse = await _connectorHolder.Connector.GetWalletPublicKeysAsync(); if (keysResponse.Result != null) { var usableKeys = keysResponse.Result.Where(n => n.CanUse).ToDictionary(n => n.EncodedPublicKey, n => n); var accountsResponse = await _connectorHolder.Connector.GetWalletAccountsAsync(max : 500); if (accountsResponse.Result != null) { Accounts = accountsResponse.Result.Where(n => usableKeys.ContainsKey(n.EncodedPublicKey)).OrderBy(n => n.AccountNumber).ToList(); } else { InfoMessage = errorInfo; return; } } else { InfoMessage = errorInfo; return; } var chatRoomsResponse = await _connectorHolder.Connector.FindAccountsAsync(type : ChatRoomType); if (chatRoomsResponse.Result != null) { var freshChatrooms = chatRoomsResponse.Result.Where(n => !string.IsNullOrEmpty(n.Name)).Select(n => new AccountInfo(n.Name, n.AccountNumber)).OrderBy(n => n.Name).ToList(); foreach (var newChatroom in freshChatrooms.Where(n => !ChatRoomAccounts.Any(m => m.AccountNumber == n.AccountNumber)).ToList()) { ChatRoomAccounts.Add(newChatroom); } var serializedChatrooms = JsonSerializer.Serialize(ChatRoomAccounts); Properties.Settings.Default.ChatRooms = serializedChatrooms; Properties.Settings.Default.Save(); } else { InfoMessage = new InfoMessageViewModel("Failed to load chatrooms! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); ChatRoomAccounts = new ObservableCollection <AccountInfo>(); return; } _isBusy = false; }
public async Task <List <Message> > LoadMessages(uint chatRoomAccountId) { var operations = new List <Operation>(); var messagesResponse = await _connectorHolder.Connector.FindDataOperationsAsync(receiverAccount : chatRoomAccountId, max : 500); if (messagesResponse.Result != null) { operations = messagesResponse.Result.ToList(); _messageDictionary = operations.Select(n => n.Senders[0].Data.Id).Distinct().ToDictionary(n => n, n => true); } else { InfoMessage = new InfoMessageViewModel("Failed to load accounts! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } return(await CreateMessages(operations)); }
public async Task InitializeAsync() { _isBusy = true; InfoMessage = new InfoMessageViewModel("Loading accounts...", null); var accountsResponse = await _holder.Connector.GetWalletAccountsAsync(max : 500); if (accountsResponse.Result != null) { Accounts = accountsResponse.Result.OrderBy(n => n.AccountNumber).ToList(); InfoMessage = null; } else { InfoMessage = new InfoMessageViewModel("Failed to load accounts! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); } _isBusy = false; }
private async Task <List <Message> > CreateMessages(IEnumerable <Operation> operations) { var accounts = Accounts.ToDictionary(n => n.AccountNumber, n => n); var operationGroups = from operation in operations group operation by new { SenderAccount = operation.Senders[0].AccountNumber, ReceiverAccount = operation.Receivers[0].AccountNumber, operation.BlockNumber, DataType = operation.Senders[0].Data.Type, operation.Senders[0].Data.Id, operation.PayloadType, } into operationsGroup select new { operationsGroup.Key, Items = operationsGroup }; var messages = new List <Message>(); foreach (var group in operationGroups) { var isContextUserSender = accounts.ContainsKey(group.Key.SenderAccount); var isContextUserReceiver = accounts.ContainsKey(group.Key.ReceiverAccount); string payload = ""; var isPublic = (group.Key.PayloadType & PayloadType.Public) == PayloadType.Public; var recipientKeyEncrypted = (group.Key.PayloadType & PayloadType.RecipientKeyEncrypted) == PayloadType.RecipientKeyEncrypted; var senderKeyEncrypted = (group.Key.PayloadType & PayloadType.SenderKeyEncrypted) == PayloadType.SenderKeyEncrypted; var passwordEncrypted = (group.Key.PayloadType & PayloadType.PasswordEncrypted) == PayloadType.PasswordEncrypted; var isAscii = (group.Key.PayloadType & PayloadType.AsciiFormatted) == PayloadType.AsciiFormatted; if (isPublic && isAscii || group.Key.PayloadType == PayloadType.NonDeterministic) { foreach (var op in group.Items.OrderBy(n => n.Senders[0].Data.Sequence)) { payload += op.Payload.FromHexString(); } } if (recipientKeyEncrypted) { if (isContextUserReceiver) { foreach (var op in group.Items.OrderBy(n => n.Senders[0].Data.Sequence)) { var decryptionResponse = await _connectorHolder.Connector.PayloadDecryptAsync(op.Payload); if (decryptionResponse.Result != null) { if (decryptionResponse.Result.Result) { payload += decryptionResponse.Result.UnencryptedPayload; } else { payload = "Cannot decrypt, perhaps receiver's public key has changed."; break; } } else { InfoMessage = new InfoMessageViewModel("Failed to load messages! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } } } else { payload = "Cannot read. Encrypted with receiver's public key."; } } if (senderKeyEncrypted) { if (isContextUserReceiver) { foreach (var op in group.Items.OrderBy(n => n.Senders[0].Data.Sequence)) { var decryptionResponse = await _connectorHolder.Connector.PayloadDecryptAsync(op.Payload); if (decryptionResponse.Result != null) { if (decryptionResponse.Result.Result) { payload += decryptionResponse.Result.UnencryptedPayload; } else { payload = "Cannot decrypt, perhaps sender's public key has changed."; break; } } else { InfoMessage = new InfoMessageViewModel("Failed to load messages! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } } } else { payload = "Cannot read. Encrypted with sender's public key."; } } if (passwordEncrypted) { foreach (var op in group.Items.OrderBy(n => n.Senders[0].Data.Sequence)) { var decryptionResponse = await _connectorHolder.Connector.PayloadDecryptAsync(op.Payload, _passwordsHolder.Passwords?.Split(Environment.NewLine) ?? new string[] { }); if (decryptionResponse.Result != null) { if (decryptionResponse.Result.Result) { payload += decryptionResponse.Result.UnencryptedPayload; } else { payload = "Cannot decrypt, wrong password."; break; } } else { InfoMessage = new InfoMessageViewModel("Failed to load messages! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } } } string senderName = string.Empty; if (accounts.ContainsKey(group.Key.SenderAccount)) { senderName = accounts[group.Key.SenderAccount].Name; } else { var senderAccountResponse = await _connectorHolder.Connector.GetAccountAsync(group.Key.SenderAccount); if (senderAccountResponse.Result != null) { senderName = senderAccountResponse.Result.Name; } else { InfoMessage = new InfoMessageViewModel("Failed to load sender name! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } } string receiverName = string.Empty; if (accounts.ContainsKey(group.Key.ReceiverAccount)) { receiverName = accounts[group.Key.ReceiverAccount].Name; } else { var receiverAccountResponse = await _connectorHolder.Connector.GetAccountAsync(group.Key.ReceiverAccount); if (receiverAccountResponse.Result != null) { receiverName = receiverAccountResponse.Result.Name; } else { InfoMessage = new InfoMessageViewModel("Failed to load receiver name! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return(null); } } var message = new Message(group.Key.SenderAccount, senderName, isContextUserSender, group.Key.ReceiverAccount, receiverName, isContextUserReceiver, group.Key.BlockNumber, group.Items.Max(n => n.Index), payload, group.Key.PayloadType, group.Items.Count()); messages.Add(message); } return(messages.OrderByDescending(n => n.BlockNumber).ThenByDescending(n => n.Index).ToList()); }
public async Task InitializeAsync() { _isBusy = true; var accounts = new Dictionary <uint, Account>(); var previousReceivers = new Dictionary <uint, bool>(); InfoMessage = new InfoMessageViewModel("Loading messages...", null); var errorInfo = new InfoMessageViewModel("Failed to load accounts! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); var keysResponse = await _connectorHolder.Connector.GetWalletPublicKeysAsync(); if (keysResponse.Result != null) { var usableKeys = keysResponse.Result.Where(n => n.CanUse).ToDictionary(n => n.EncodedPublicKey, n => n); var accountsResponse = await _connectorHolder.Connector.GetWalletAccountsAsync(max : 500); if (accountsResponse.Result != null) { Accounts = accountsResponse.Result.Where(n => usableKeys.ContainsKey(n.EncodedPublicKey)).OrderBy(n => n.AccountNumber).ToList(); accounts = Accounts.ToDictionary(n => n.AccountNumber, n => n); } else { InfoMessage = errorInfo; return; } } else { InfoMessage = errorInfo; return; } var operations = new List <Operation>(); foreach (var account in Accounts) { var receivedMessagesResponse = await _connectorHolder.Connector.FindDataOperationsAsync(receiverAccount : account.AccountNumber, max : int.MaxValue); if (receivedMessagesResponse.Result != null) { operations.AddRange(receivedMessagesResponse.Result); } else { InfoMessage = new InfoMessageViewModel("Failed to load messages! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return; } var sentMessagesResponse = await _connectorHolder.Connector.FindDataOperationsAsync(senderAccount : account.AccountNumber, max : int.MaxValue); if (sentMessagesResponse.Result != null) { foreach (var op in sentMessagesResponse.Result) { //if sender and receiver is your account, then avoid duplicate messages if (!accounts.ContainsKey(op.Senders[0].AccountNumber) || !accounts.ContainsKey(op.Receivers[0].AccountNumber)) { operations.Add(op); } previousReceivers[op.Receivers[0].AccountNumber] = true; } } else { InfoMessage = new InfoMessageViewModel("Failed to load messages! Check if Pascal Wallet is open and if it accepts connections.", () => InfoMessage = null, true); return; } } _messageDictionary = operations.Select(n => n.Senders[0].Data.Id).Distinct().ToDictionary(n => n, n => true); PreviousReceivers = previousReceivers.Keys.OrderBy(n => n).ToList(); Messages = await CreateMessages(operations); InfoMessage = null; _isBusy = false; }