private static SearchQuery ApplyBool(SearchQuery query, bool?value, SearchQuery ifTrue, SearchQuery ifFalse)
{
if (value == true)
{
return(query.And(ifTrue));
}
if (value == false)
{
return(query.And(ifFalse));
}
return(query);
}
public virtual async Task <ConnectionRecord> ResolveByMyKeyAsync(IAgentContext agentContext, string myKey)
{
if (string.IsNullOrEmpty(myKey))
{
throw new ArgumentNullException(nameof(myKey));
}
if (agentContext == null)
{
throw new ArgumentNullException(nameof(agentContext));
}
var record =
// Check if key is part of a connection
(await ListAsync(agentContext,
SearchQuery.Equal(nameof(ConnectionRecord.MyVk), myKey), 5))
.SingleOrDefault()
// Check if key is part of a multiparty invitation
?? (await ListAsync(agentContext,
SearchQuery.And(
SearchQuery.Equal(TagConstants.ConnectionKey, myKey),
SearchQuery.Equal(nameof(ConnectionRecord.MultiPartyInvitation), "True")), 5))
.SingleOrDefault()
// Check if key is part of a single party invitation
?? (await ListAsync(agentContext,
SearchQuery.Equal(TagConstants.ConnectionKey, myKey), 5))
.SingleOrDefault();
return(record);
}
public static List <MimeMessage> MailAddresFilter(ImapClient client, string ReadType, CodeActivityContext context, InArgument <string> FilterText, bool MarkAsRead)
{
List <MimeMessage> MessageList = new List <MimeMessage>();
IList <UniqueId> uids = client.Inbox.Search(SearchQuery.All);
if (ReadType == "UnRead")
{
uids = client.Inbox.Search(SearchQuery.And(SearchQuery.NotSeen, SearchQuery.FromContains(FilterText.Get(context).ToString())));
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
else if (ReadType == "Read")
{
uids = client.Inbox.Search(SearchQuery.And(SearchQuery.Seen, SearchQuery.FromContains(FilterText.Get(context).ToString())));
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
else
{
uids = client.Inbox.Search(SearchQuery.FromContains(FilterText.Get(context).ToString()));
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
}
public static List <MimeMessage> NoFilter(ImapClient client, string ReadType, bool MarkAsRead)
{
List <MimeMessage> MessageList = new List <MimeMessage>();
IList <UniqueId> uids = client.Inbox.Search(SearchQuery.All);
if (ReadType == "UnRead")
{
uids = client.Inbox.Search(SearchQuery.And(SearchQuery.NotSeen, SearchQuery.All));
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
else if (ReadType == "Read")
{
uids = client.Inbox.Search(SearchQuery.And(SearchQuery.Seen, SearchQuery.All));
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
else
{
uids = client.Inbox.Search(SearchQuery.All);
if (MarkAsRead)
{
client.Inbox.AddFlags(uids, MessageFlags.Seen, true);
}
return(MessageList = uids.AsEnumerable().Select(x => client.Inbox.GetMessage(x)).ToList());
}
}
public void TestArgumentExceptions()
{
Assert.Throws <ArgumentNullException> (() => SearchQuery.And(null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => SearchQuery.And(SearchQuery.All, null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.BccContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.BccContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.BodyContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.BodyContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.CcContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.CcContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.DoesNotHaveCustomFlag(null));
Assert.Throws <ArgumentException> (() => SearchQuery.DoesNotHaveCustomFlag(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.DoesNotHaveCustomFlags(null));
Assert.Throws <ArgumentException> (() => SearchQuery.DoesNotHaveFlags(MessageFlags.None));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Filter(null));
Assert.Throws <ArgumentException> (() => SearchQuery.Filter(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.FromContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.FromContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Fuzzy(null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.GMailRawSearch(null));
Assert.Throws <ArgumentException> (() => SearchQuery.GMailRawSearch(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasCustomFlag(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasCustomFlag(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasCustomFlags(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasFlags(MessageFlags.None));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasGMailLabel(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasGMailLabel(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HeaderContains(null, "text"));
Assert.Throws <ArgumentException> (() => SearchQuery.HeaderContains(string.Empty, "text"));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HeaderContains("name", null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.LargerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.MessageContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.MessageContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Not(null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.OlderThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Or(null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Or(SearchQuery.All, null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.SmallerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.SubjectContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.SubjectContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.ToContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.ToContains(string.Empty));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.YoungerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.All.And(null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.All.Or(null));
Assert.Throws <ArgumentNullException> (() => new BinarySearchQuery(SearchTerm.And, null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => new BinarySearchQuery(SearchTerm.And, SearchQuery.All, null));
Assert.Throws <ArgumentNullException> (() => new FilterSearchQuery(null));
Assert.Throws <ArgumentException> (() => new FilterSearchQuery(string.Empty));
Assert.Throws <ArgumentNullException> (() => new HeaderSearchQuery(null, "text"));
Assert.Throws <ArgumentException> (() => new HeaderSearchQuery(string.Empty, "text"));
Assert.Throws <ArgumentNullException> (() => new HeaderSearchQuery("name", null));
Assert.Throws <ArgumentNullException> (() => new TextSearchQuery(SearchTerm.BodyContains, null));
Assert.Throws <ArgumentNullException> (() => new UidSearchQuery(null));
Assert.Throws <ArgumentException> (() => new UidSearchQuery(new UniqueIdSet()));
Assert.Throws <ArgumentException> (() => new UidSearchQuery(UniqueId.Invalid));
Assert.Throws <ArgumentNullException> (() => new UnarySearchQuery(SearchTerm.Not, null));
}
public async Task Run([TimerTrigger("0 */5 * * * *", RunOnStartup = true)] TimerInfo timerInfo)
{
logger.LogInformation("Starting");
using var client = new ImapClient();
logger.LogDebug("Connecting to {HostName}:{Port}", options.HostName, options.Port);
await client.ConnectAsync(options.HostName, options.Port);
logger.LogDebug("Authenticating {UserName}", options.UserName);
await client.AuthenticateAsync(options.UserName, options.Password);
logger.LogInformation("Connected");
var inbox = client.Inbox;
await inbox.OpenAsync(FolderAccess.ReadOnly);
var state = await stateProvider.Read();
if (state.HighestModSeq >= inbox.HighestModSeq)
{
logger.LogInformation("Mailbox is unchanged");
return;
}
var historyQuery = state.HighestModSeq == 0
? SearchQuery.DeliveredAfter(DateTime.UtcNow.Subtract(options.MaximumMessageAge))
: SearchQuery.ChangedSince(state.HighestModSeq);
foreach (var processor in processors)
{
logger.LogInformation("Processing {0}", processor.Description);
var query = SearchQuery.And(historyQuery, processor.Query);
var ids = await inbox.SearchAsync(query);
foreach (var id in ids)
{
var message = await inbox.GetMessageAsync(id);
if (state.KnownMessageIds.Contains(message.MessageId))
{
logger.LogDebug("Skipping known message id {MessageId}", message.MessageId);
continue;
}
var isProcessed = await processor.Process(message);
if (isProcessed)
{
logger.LogDebug("Adding message id {MessageId} to known message IDs", message.MessageId);
state.KnownMessageIds.Add(message.MessageId);
}
}
}
state.HighestModSeq = inbox.HighestModSeq;
client.Disconnect(true);
await stateProvider.Write(state);
}
public void TestReduceAnd()
{
var query = optimizer.Reduce(SearchQuery.And(SearchQuery.All, SearchQuery.Answered));
Assert.AreEqual(SearchQuery.Answered, query);
query = optimizer.Reduce(SearchQuery.And(SearchQuery.Answered, SearchQuery.All));
Assert.AreEqual(SearchQuery.Answered, query);
}
public List <EmailViewModel> GetMailings <T>(DateTime?lastReceivedDate, T user) where T : IUser
{
if (string.IsNullOrEmpty(user.Email))
{
return(null);
}
List <EmailViewModel> emailsList = new List <EmailViewModel>();
using (var client = new ImapClient())
{
using (var cancel = new CancellationTokenSource())
{
client.SslProtocols = Tls | Tls11 | Tls12;
client.ServerCertificateValidationCallback =
new RemoteCertificateValidationCallback(ServificateValidationCallBack);
client.Connect("imap.gmail.com", 993, true, cancel.Token);
client.AuthenticationMechanisms.Remove("XOAUTH");
client.Authenticate(Email, Password, cancel.Token);
var inbox = client.Inbox;
inbox.Open(FolderAccess.ReadOnly, cancel.Token);
SearchQuery query = SearchQuery.FromContains(user.Email);
if (lastReceivedDate != null)
{
query = query.And(SearchQuery.SentAfter(lastReceivedDate.Value));
}
var result = inbox.Search(query, cancel.Token);
foreach (var uid in result)
{
var message = inbox.GetMessage(uid, cancel.Token);
if (lastReceivedDate != null && message.Date > lastReceivedDate.Value)
{
emailsList.Add(new EmailViewModel(message));
}
}
client.Disconnect(true, cancel.Token);
}
}
if (emailsList.Any())
{
new Task(() => { SaveEmail(emailsList, user); }).Start();
}
return(emailsList);
}
private SearchQuery CreateQuery(MailAdapterProviderParameters providerParameters)
{
SearchQuery query = SearchQuery.All;
if (!string.IsNullOrWhiteSpace(providerParameters.FromContains))
{
query = query.And(SearchQuery.FromContains(providerParameters.FromContains.Trim()));
}
if (!string.IsNullOrWhiteSpace(providerParameters.ToContains))
{
query = query.And(SearchQuery.ToContains(providerParameters.ToContains.Trim()));
}
if (!string.IsNullOrWhiteSpace(providerParameters.SubjectContains))
{
query = query.And(SearchQuery.SubjectContains(providerParameters.SubjectContains.Trim()));
}
if (providerParameters.OnlyNotRead.HasValue && providerParameters.OnlyNotRead.Value)
{
query = query.And(SearchQuery.NotSeen);
}
return(query);
}
public void SearchQueryFact008()
{
// Arrange
var solrOptions = new SolrExpressOptions();
var solrConnection = new FakeSolrConnection <TechProductDocument>();
var expressionBuilder = new ExpressionBuilder <TechProductDocument>(solrOptions, solrConnection);
expressionBuilder.LoadDocument();
var searchQuery = new SearchQuery <TechProductDocument>(expressionBuilder);
// Act
var result = searchQuery.And(q => q.EqualsTo(10)).Execute();
// Assert
Assert.Equal(" AND (10)", result);
}
/// <summary>
/// 查询出所有的邮件真实Id
/// </summary>
/// <param name="AfterTime">时间节点</param>
/// <param name="IsNotSeen">是否只查询未读邮件</param>
/// <returns></returns>
public List <UniqueId> QueryReceiveMailId(DateTime?AfterTime = null, bool IsNotSeen = true)
{
try
{
//打开收件箱文件夹
_client.Inbox.Open(FolderAccess.ReadWrite);
//获取邮箱条件,默认获取未读邮件，如果有时间条件，则获取大于这个时间的邮件
var MailSeachQuery = SearchQuery.NotSeen;
if (AfterTime != null)
{
if (IsNotSeen)
{
MailSeachQuery = SearchQuery.And(SearchQuery.DeliveredAfter(AfterTime.Value), SearchQuery.NotSeen);
}
else
{
MailSeachQuery = SearchQuery.DeliveredAfter(AfterTime.Value);
}
}
else
{
if (IsNotSeen)
{
MailSeachQuery = SearchQuery.NotSeen;
}
else
{
MailSeachQuery = SearchQuery.All;
}
}
//获取邮件Id集合
var EmailIds = _client.Inbox.Search(MailSeachQuery);
if (EmailIds != null && EmailIds.Count > 0)
{
return(EmailIds.ToList());
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Returns the query object used to search the email body text,
/// derived from each line of the input text file
/// </summary>
/// <param name="fileName">The relative path of the desired text file</param>
/// <param name="retrospect">Boolean indicating if query needs (and contains retrospect) appended</param>
/// <returns></returns>
public static SearchQuery GetSearchQuery(string fileName, bool retrospect)
{
string[] queries = File.ReadAllLines(fileName);
// Get first search term
SearchQuery search = SearchQuery.BodyContains(queries[0]);
// Get consecutive search terms and concatenate them into a large or statement
for (int i = 1; i < queries.Length; i++)
{
search = search.Or(SearchQuery.BodyContains(queries[i]));
}
// Add a check for the sendee being the retrospect client if retrospect = true
search = retrospect ? search.And(SearchQuery.FromContains("NewDesktop Retrospect NAS")) : search;
return(search);
}
public async Task CanSearchMulipleProperties()
{
var record1 = new ConnectionRecord {
State = ConnectionState.Connected, Id = "1"
};
var record2 = new ConnectionRecord
{
State = ConnectionState.Connected,
Id = "2"
};
record2.SetTag("tagName", "tagValue");
var record3 = new ConnectionRecord
{
State = ConnectionState.Invited,
Id = "3"
};
record3.SetTag("tagName", "tagValue");
await _recordService.AddAsync(_wallet, record1);
await _recordService.AddAsync(_wallet, record2);
await _recordService.AddAsync(_wallet, record3);
var searchResult = await _recordService.SearchAsync <ConnectionRecord>(_wallet,
SearchQuery.And(
SearchQuery.Equal("State", ConnectionState.Connected.ToString("G")),
SearchQuery.Equal("tagName", "tagValue")
), null, 10);
Assert.Single(searchResult);
Assert.Equal("2", searchResult.Single().Id);
}
public IEnumerable<MimeMessage> GetMessages(SearchQuery query)
{
using (var client = GetImapClient())
{
var folder = client.Inbox;
folder.Open(FolderAccess.ReadWrite);
var messages = new List<MimeMessage>();
// ignore messages marked for deletion
foreach (var uid in folder.Search(SearchQuery.And(query, SearchQuery.NotDeleted)))
{
try
{
var message = folder.GetMessage(uid);
messages.Add(message);
var addresses = new List<MailboxAddress>();
foreach (var to in message.To)
{
var result = to as MailboxAddress;
if (result == null)
{
continue;
}
addresses.Add(result);
}
}
catch (Exception ex)
{
Console.WriteLine(ex); // keep trying each message
}
}
return messages;
}
}
/// <summary>
/// Retrieves a <see cref="ConnectionRecord"/> by key.
/// </summary>
/// <returns>The connection record.</returns>
/// <param name="connectionService">Connection service.</param>
/// <param name="agentContext">Agent Context.</param>
/// <param name="myKey">My key.</param>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="AgentFrameworkException">Throw with error code 'RecordNotFound' if a connection record for the key was not found</exception>
public static async Task <ConnectionRecord> ResolveByMyKeyAsync(
this IConnectionService connectionService, IAgentContext agentContext, string myKey)
{
if (string.IsNullOrEmpty(myKey))
{
throw new ArgumentNullException(nameof(myKey));
}
if (agentContext == null)
{
throw new ArgumentNullException(nameof(agentContext));
}
var record =
// Check if key is part of a connection
(await connectionService.ListAsync(agentContext,
SearchQuery.Equal(nameof(ConnectionRecord.MyVk), myKey), 5))
.SingleOrDefault()
// Check if key is part of a multiparty invitation
?? (await connectionService.ListAsync(agentContext,
SearchQuery.And(
SearchQuery.Equal(TagConstants.ConnectionKey, myKey),
SearchQuery.Equal(nameof(ConnectionRecord.MultiPartyInvitation), "True")), 5))
.SingleOrDefault()
// Check if key is part of a single party invitation
?? (await connectionService.ListAsync(agentContext,
SearchQuery.Equal(TagConstants.ConnectionKey, myKey), 5))
.SingleOrDefault();
if (record == null)
{
throw new AgentFrameworkException(ErrorCode.RecordNotFound, $"Connection Record not found for key {myKey}");
}
return(record);
}
public async Task ReturnsEmptyIfNoRecordsMatchCriteria()
{
var record = new ConnectionRecord
{
Id = Guid.NewGuid().ToString(),
State = ConnectionState.Invited
};
record.SetTag("tagName", "tagValue");
await _recordService.AddAsync(_wallet, record);
await _recordService.AddAsync(_wallet,
new ConnectionRecord { Id = Guid.NewGuid().ToString(), State = ConnectionState.Connected });
var searchResult = await _recordService.SearchAsync <ConnectionRecord>(_wallet,
SearchQuery.And(
SearchQuery.Equal("State", ConnectionState.Connected.ToString("G")),
SearchQuery.Equal("tagName", "tagValue")
), null, 10);
Assert.Empty(searchResult);
}
public async Task <IList <UniqueId> > GetInboxAsync(string to = null, string re = null)
{
if (!_client.IsAuthenticated)
{
throw new UnauthorizedAccessException();
}
// NOTE: An open IMailFolder does not seem to be refreshed with the latest messages
//if (!_client.Inbox.IsOpen)
//{
// _client.Inbox.Open(FolderAccess.ReadOnly);
//}
ReOpen(_client.Inbox, FolderAccess.ReadOnly);
var query = new SearchQuery();
if (!string.IsNullOrEmpty(to))
{
query = SearchQuery.And(query, SearchQuery.ToContains(to));
}
if (!string.IsNullOrEmpty(re))
{
query = SearchQuery.And(query, SearchQuery.SubjectContains(re));
}
//if (date != null)
//{
// // https://github.com/jstedfast/MimeKit/issues/502
// query = SearchQuery.And(query, SearchQuery.DeliveredAfter(date.Value));
//}
var uids = await _client.Inbox.SearchAsync(query);
return(uids);
}
public async Task SendPaymentRequest()
{
// Create two agent hosts and establish pairwise connection between them
var agents = await InProcAgent.CreatePairedAsync(true);
// Get each agent payment address records
var paymentAddress1 = await agents.Agent1.Payments.GetDefaultPaymentAddressAsync(agents.Agent1.Context);
var paymentAddress2 = await agents.Agent2.Payments.GetDefaultPaymentAddressAsync(agents.Agent2.Context);
// Internal reference number for this payment
const string paymentReference = "INVOICE# 0001";
// Setup a basic use case for payments by using basic messages
// Any AgentMessage can be used to attach payment requests and receipts
var basicMessage = new BasicMessage {
Content = "This is payment request"
};
// Attach the payment request to the agent message
var paymentRecord1 = await agents.Agent1.Payments.AttachPaymentRequestAsync(
context : agents.Agent1.Context,
agentMessage : basicMessage,
details : new PaymentDetails
{
Id = paymentReference,
Items = new List <PaymentItem>
{
new PaymentItem {
Label = "Item 1", Amount = 8
},
new PaymentItem {
Label = "Tax", Amount = 2
}
},
Total = new PaymentItem
{
Amount = new PaymentAmount
{
Currency = "sov",
Value = 10
},
Label = "Total"
}
},
payeeAddress : paymentAddress1);
// PaymentRecord expectations
Assert.NotNull(paymentRecord1);
Assert.Equal(10UL, paymentRecord1.Amount);
Assert.Equal(paymentAddress1.Address, paymentRecord1.Address);
Assert.Equal(PaymentState.Requested, paymentRecord1.State);
// Ensure the payment request is attached to the message
var decorator = basicMessage.FindDecorator <PaymentRequestDecorator>("payment_request");
Assert.NotNull(decorator);
// Send the message to agent 2
await agents.Agent1.Messages.SendAsync(agents.Agent1.Context.Wallet, basicMessage, agents.Connection1);
// Find the payment record in the context of agent 2
var search = await agents.Agent2.Records.SearchAsync <PaymentRecord>(
wallet : agents.Agent2.Context.Wallet,
query : SearchQuery.And(
SearchQuery.Equal(nameof(PaymentRecord.ReferenceId), paymentReference),
SearchQuery.Equal(nameof(PaymentRecord.ConnectionId), agents.Connection2.Id)));
var paymentRecord2 = search.FirstOrDefault();
Assert.Single(search);
Assert.NotNull(paymentRecord2);
Assert.Equal(PaymentState.RequestReceived, paymentRecord2.State);
// Fund payment address of agent 2 so we can make payment to agent 1
await FundAccountAsync(50UL, paymentAddress2.Address);
// Refresh balance to ensure it is funded correctly
await agents.Agent2.Payments.RefreshBalanceAsync(agents.Agent2.Context, paymentAddress2);
Assert.Equal(50UL, paymentAddress2.Balance);
// Make payment for received request
await agents.Agent2.Payments.MakePaymentAsync(agents.Agent2.Context, paymentRecord2, paymentAddress2);
Assert.Equal(PaymentState.Paid, paymentRecord2.State);
Assert.Equal(40UL, paymentAddress2.Balance);
Assert.NotNull(paymentRecord2.ReceiptId);
// Send a basic message back to agent 1 and attach a payment receipt
var message2 = new BasicMessage {
Content = "Here's a receipt"
};
// Attach a payment receipt to the basic message
// Receipts can be attached to any agent message
agents.Agent2.Payments.AttachPaymentReceipt(agents.Agent2.Context, message2, paymentRecord2);
// Send the message to agent 1
await agents.Agent2.Messages.SendAsync(agents.Agent2.Context.Wallet, message2, agents.Connection2);
// Fetch payment record 1 again, to refresh state
paymentRecord1 = await agents.Agent1.Records.GetAsync <PaymentRecord>(agents.Agent1.Context.Wallet, paymentRecord1.Id);
// Check payment record 1 for receipt
Assert.Equal(PaymentState.ReceiptReceived, paymentRecord1.State);
Assert.NotNull(paymentRecord1.ReceiptId);
// Check agent 1 balance
await agents.Agent1.Payments.RefreshBalanceAsync(agents.Agent1.Context, paymentAddress1);
Assert.Equal(10UL, paymentAddress1.Balance);
// Verify the payment receipt on the ledger
var verified = await agents.Agent1.Payments.VerifyPaymentAsync(agents.Agent1.Context, paymentRecord1);
Assert.True(verified);
// Clean things up and shut down hosts gracefully
await agents.Agent1.DisposeAsync();
await agents.Agent2.DisposeAsync();
}
/// <inheritdoc />
public virtual async Task <string> ProcessCredentialAsync(IAgentContext agentContext, CredentialMessage credential, ConnectionRecord connection)
{
var offer = JObject.Parse(credential.CredentialJson);
var definitionId = offer["cred_def_id"].ToObject <string>();
var schemaId = offer["schema_id"].ToObject <string>();
var revRegId = offer["rev_reg_id"]?.ToObject <string>();
// TODO: Replace this with thread lookup
// Currently, this is unable to process multiple offers and requests reliably
var credentialSearch =
await RecordService.SearchAsync <CredentialRecord>(agentContext.Wallet,
SearchQuery.And(
SearchQuery.Equal(nameof(CredentialRecord.SchemaId), schemaId),
SearchQuery.Equal(nameof(CredentialRecord.CredentialDefinitionId), definitionId),
SearchQuery.Equal(nameof(CredentialRecord.ConnectionId), connection.Id),
SearchQuery.Equal(nameof(CredentialRecord.State), CredentialState.Requested.ToString("G"))
), null, 5);
if (credentialSearch.Count == 0)
{
throw new AgentFrameworkException(ErrorCode.RecordNotFound, "Credential record not found");
}
var credentialRecord = credentialSearch.Single();
// TODO: Should resolve if multiple credential records are found
if (credentialRecord.State != CredentialState.Requested)
{
throw new AgentFrameworkException(ErrorCode.RecordInInvalidState,
$"Credential state was invalid. Expected '{CredentialState.Requested}', found '{credentialRecord.State}'");
}
var credentialDefinition = await LedgerService.LookupDefinitionAsync(agentContext.Pool, definitionId);
string revocationRegistryDefinitionJson = null;
if (!string.IsNullOrEmpty(revRegId))
{
// If credential supports revocation, lookup registry definition
var revocationRegistry =
await LedgerService.LookupRevocationRegistryDefinitionAsync(agentContext.Pool, revRegId);
revocationRegistryDefinitionJson = revocationRegistry.ObjectJson;
}
var credentialId = await AnonCreds.ProverStoreCredentialAsync(agentContext.Wallet, null,
credentialRecord.CredentialRequestMetadataJson,
credential.CredentialJson, credentialDefinition.ObjectJson, revocationRegistryDefinitionJson);
credentialRecord.CredentialId = credentialId;
await credentialRecord.TriggerAsync(CredentialTrigger.Issue);
await RecordService.UpdateAsync(agentContext.Wallet, credentialRecord);
EventAggregator.Publish(new ServiceMessageProcessingEvent
{
RecordId = credentialRecord.Id,
MessageType = credential.Type,
});
return(credentialRecord.Id);
}
public SearchQuery CreateSearchQuery()
{
var query = new SearchQuery();
query = ApplyBool(query, Answered, SearchQuery.Answered, SearchQuery.NotAnswered);
query = ApplyBool(query, Recent, SearchQuery.Recent, SearchQuery.NotRecent);
query = ApplyBool(query, Deleted, SearchQuery.Deleted, SearchQuery.NotDeleted);
query = ApplyBool(query, Flagged, SearchQuery.Flagged, SearchQuery.NotFlagged);
query = ApplyBool(query, Seen, SearchQuery.Seen, SearchQuery.NotSeen);
query = ApplyBool(query, New, SearchQuery.New, SearchQuery.Not(SearchQuery.New)); // TODO: Not(New) ??
if (Bcc != null)
{
query = query.And(SearchQuery.BccContains(Bcc));
}
if (Cc != null)
{
query = query.And(SearchQuery.CcContains(Cc));
}
if (To != null)
{
query = query.And(SearchQuery.ToContains(To));
}
if (From != null)
{
query = query.And(SearchQuery.ToContains(From));
}
if (Subject != null)
{
query = query.And(SearchQuery.ToContains(Subject));
}
if (Text != null)
{
query = query.And(SearchQuery.ToContains(Text));
}
if (Body != null)
{
query = query.And(SearchQuery.ToContains(Body));
}
if (PostDating != null)
{
query = query.And(SearchQuery.SentOn((DateTime)PostDating));
}
if (BeforeDateOfPosting != null)
{
query = query.And(SearchQuery.SentBefore((DateTime)BeforeDateOfPosting));
}
if (AfterDateOfPosting != null)
{
query = query.And(SearchQuery.SentAfter((DateTime)AfterDateOfPosting));
}
return(query);
}
public void TestArgumentExceptions()
{
Assert.Throws <ArgumentNullException> (() => SearchQuery.And(null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => SearchQuery.And(SearchQuery.All, null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.AnnotationsContain(null, AnnotationAttribute.Value, "value"));
Assert.Throws <ArgumentNullException> (() => SearchQuery.AnnotationsContain(AnnotationEntry.AltSubject, null, "value"));
Assert.Throws <ArgumentException> (() => SearchQuery.AnnotationsContain(AnnotationEntry.AltSubject, AnnotationAttribute.Size, "value"));
Assert.Throws <ArgumentNullException> (() => SearchQuery.BccContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.BccContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.BodyContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.BodyContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.CcContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.CcContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.DoesNotHaveCustomFlag(null));
Assert.Throws <ArgumentException> (() => SearchQuery.DoesNotHaveCustomFlag(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.DoesNotHaveCustomFlags(null));
Assert.Throws <ArgumentException> (() => SearchQuery.DoesNotHaveCustomFlags(new string[0]));
Assert.Throws <ArgumentException> (() => SearchQuery.DoesNotHaveFlags(MessageFlags.None));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Filter(null));
Assert.Throws <ArgumentException> (() => SearchQuery.Filter(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.FromContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.FromContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Fuzzy(null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.GMailRawSearch(null));
Assert.Throws <ArgumentException> (() => SearchQuery.GMailRawSearch(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasCustomFlag(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasCustomFlag(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasCustomFlags(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasCustomFlags(new string[0]));
Assert.Throws <ArgumentException> (() => SearchQuery.HasFlags(MessageFlags.None));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasKeyword(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasKeyword(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasKeywords(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasKeywords(new string[0]));
Assert.Throws <ArgumentException> (() => SearchQuery.HasKeywords(new string[] { "keyword", null }));
Assert.Throws <ArgumentException> (() => SearchQuery.NotFlags(MessageFlags.None));
Assert.Throws <ArgumentNullException> (() => SearchQuery.NotKeyword(null));
Assert.Throws <ArgumentException> (() => SearchQuery.NotKeyword(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.NotKeywords(null));
Assert.Throws <ArgumentException> (() => SearchQuery.NotKeywords(new string[0]));
Assert.Throws <ArgumentException> (() => SearchQuery.NotKeywords(new string [] { "keyword", null }));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HasGMailLabel(null));
Assert.Throws <ArgumentException> (() => SearchQuery.HasGMailLabel(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HeaderContains(null, "text"));
Assert.Throws <ArgumentException> (() => SearchQuery.HeaderContains(string.Empty, "text"));
Assert.Throws <ArgumentNullException> (() => SearchQuery.HeaderContains("name", null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.LargerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.MessageContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.MessageContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Not(null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.OlderThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Or(null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => SearchQuery.Or(SearchQuery.All, null));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.SmallerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.SubjectContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.SubjectContains(string.Empty));
Assert.Throws <ArgumentNullException> (() => SearchQuery.ToContains(null));
Assert.Throws <ArgumentException> (() => SearchQuery.ToContains(string.Empty));
Assert.Throws <ArgumentOutOfRangeException> (() => SearchQuery.YoungerThan(-1));
Assert.Throws <ArgumentNullException> (() => SearchQuery.All.And(null));
Assert.Throws <ArgumentNullException> (() => SearchQuery.All.Or(null));
Assert.Throws <ArgumentNullException> (() => new BinarySearchQuery(SearchTerm.And, null, SearchQuery.All));
Assert.Throws <ArgumentNullException> (() => new BinarySearchQuery(SearchTerm.And, SearchQuery.All, null));
Assert.Throws <ArgumentNullException> (() => new FilterSearchQuery(null));
Assert.Throws <ArgumentException> (() => new FilterSearchQuery(string.Empty));
Assert.Throws <ArgumentException> (() => new FilterSearchQuery(MetadataTag.Create("/dev/null")));
Assert.Throws <ArgumentNullException> (() => new HeaderSearchQuery(null, "text"));
Assert.Throws <ArgumentException> (() => new HeaderSearchQuery(string.Empty, "text"));
Assert.Throws <ArgumentNullException> (() => new HeaderSearchQuery("name", null));
Assert.Throws <ArgumentNullException> (() => new TextSearchQuery(SearchTerm.BodyContains, null));
Assert.Throws <ArgumentNullException> (() => new UidSearchQuery(null));
Assert.Throws <ArgumentException> (() => new UidSearchQuery(new UniqueIdSet()));
Assert.Throws <ArgumentException> (() => new UidSearchQuery(UniqueId.Invalid));
Assert.Throws <ArgumentNullException> (() => new UnarySearchQuery(SearchTerm.Not, null));
}
private async Task <IEnumerable <Email> > GetEmails(EmailSearchQuery query)
{
this.logger.Debug("Loading inbox emails started");
this.logger.Debug($"Inbox emails query: {query}");
IEnumerable <Email> emails;
using (var client = new ImapClient())
{
await client.ConnectAsync(
this.imapSettings.Host,
this.imapSettings.Port);
await client.AuthenticateAsync(this.imapSettings.User, this.imapSettings.Password);
await client.Inbox.OpenAsync(FolderAccess.ReadOnly);
var inboxQuery = new SearchQuery();
if (!string.IsNullOrWhiteSpace(query.Subject))
{
inboxQuery = inboxQuery.And(SearchQuery.SubjectContains(query.Subject));
}
var ids = await client.Inbox.SearchAsync(inboxQuery);
if (query.MinId != null)
{
ids = ids.Where(x => x.Id > query.MinId).ToList();
}
var messages = (await client.Inbox
.FetchAsync(ids, MessageSummaryItems.BodyStructure | MessageSummaryItems.Envelope))
.OrderByDescending(m => m.Date)
.ToList();
if (!string.IsNullOrWhiteSpace(query.Sender))
{
messages = messages
.Where(m => m.Envelope.From.Any(f => f.ToString().Contains(query.Sender)))
.ToList();
}
if (query.LastNEmails != null)
{
messages = messages
.Take((int)query.LastNEmails.Value)
.ToList();
}
this.logger.Debug($"Total messages loaded: {messages.Count}");
emails = this.ConvertMessages(client, messages);
await client.DisconnectAsync(true);
}
this.logger.Debug("Loading inbox emails finished");
return(emails);
}
/// <summary>
/// Retrieves a list of <see cref="ConnectionRecord"/> that are multi-party invitations.
/// </summary>
/// <returns>The invited connections async.</returns>
/// <param name="connectionService">Connection service.</param>
/// <param name="agentContext">Agent Context.</param>
/// <param name="count">Count.</param>
public static Task <List <ConnectionRecord> > ListMultiPartyInvitationsAsync(
this IConnectionService connectionService, IAgentContext agentContext, int count = 100)
=> connectionService.ListAsync(agentContext,
SearchQuery.And(SearchQuery.Equal(nameof(ConnectionRecord.State), ConnectionState.Invited.ToString("G")),
SearchQuery.Equal(nameof(ConnectionRecord.MultiPartyInvitation), true.ToString())), count);
private async Task SelectCredentialsForProofAsync(IAgentContext agentContext, ProofRecord proof, ConnectionRecord connection)
{
var requestJson = (JObject)JsonConvert.DeserializeObject(proof.RequestJson);
JObject _requestedAttributes = (JObject)requestJson["requested_attributes"];
JObject _requestedPredicates = (JObject)requestJson["requested_predicates"];
IList <string> _requestedAttributesKeys = _requestedAttributes?.Properties().Select(p => p.Name).ToList();
IList <string> _requestedPredicatesKeys = _requestedPredicates?.Properties().Select(p => p.Name).ToList();
JToken cred_def_id = null;
try
{
cred_def_id = _requestedAttributes[_requestedAttributesKeys[0]]["restrictions"][0]["cred_def_id"];
}
catch (Exception)
{
cred_def_id = null;
}
var credentials = new List <CredentialRecord>();
if (cred_def_id != null)
{
credentials = await RecordService.SearchAsync <CredentialRecord>(agentContext.Wallet,
SearchQuery.And(SearchQuery.Equal(nameof(CredentialRecord.State), CredentialState.Issued.ToString("G")),
SearchQuery.Equal(nameof(CredentialRecord.CredentialDefinitionId), cred_def_id.ToString())), null, 100);
}
else
{
credentials = await RecordService.SearchAsync <CredentialRecord>(agentContext.Wallet,
SearchQuery.Equal(nameof(CredentialRecord.State), CredentialState.Issued.ToString("G")), null, 100);
}
bool credentialFound = false;
if (credentials.Count > 0)
{
Dictionary <string, RequestedAttribute> requestedAttributes = new Dictionary <string, RequestedAttribute>();
Dictionary <string, RequestedAttribute> requestedPredicates = new Dictionary <string, RequestedAttribute>();
foreach (var credential in credentials)
{
if (!credentialFound)
{
IEnumerable <CredentialAttribute> Attributes = credential.CredentialAttributesValues
.Select(p =>
new CredentialAttribute()
{
Name = p.Name,
Value = p.Value?.ToString(),
Type = "Text"
})
.ToList();
foreach (var item in _requestedAttributesKeys)
{
foreach (var attrib in Attributes)
{
if (_requestedAttributes[item]["name"].ToString() == attrib.Name)
{
RequestedAttribute requestedAttribute = new RequestedAttribute();
requestedAttribute.CredentialId = credential.CredentialId;
requestedAttribute.Revealed = true;
requestedAttribute.Timestamp = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds();
requestedAttributes.Add(item, requestedAttribute);
credentialFound = true;
}
}
if (!credentialFound)
{
requestedAttributes.Clear();
}
}
foreach (var item in _requestedPredicatesKeys)
{
RequestedAttribute requestedAttribute = new RequestedAttribute();
requestedAttribute.CredentialId = credential.CredentialId;
requestedAttribute.Timestamp = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds();
requestedPredicates.Add(item, requestedAttribute);
}
}
}
if (credentialFound)
{
RequestedCredentials requestedCredentials = new RequestedCredentials();
requestedCredentials.RequestedAttributes = requestedAttributes;
requestedCredentials.RequestedPredicates = requestedPredicates;
var proofJson = await CreateProofJsonAsync(agentContext, requestedCredentials, proof.RequestJson);
var threadId = proof.GetTag(TagConstants.LastThreadId);
var proofMsg = new ProofMessage
{
ProofJson = proofJson
};
proofMsg.ThreadFrom(threadId);
await MessageService.SendAsync(agentContext.Wallet, proofMsg, connection);
}
}
}
