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