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;
}
