static void SearchWithRegularExpression() { //open document Document pdfDocument = new Document(Config.TestPdf); //create TextAbsorber object to find all the phrases matching the regular expression TextFragmentAbsorber textFragmentAbsorber = new TextFragmentAbsorber("\\d{4}-\\d{4}"); //like 1999-2000 //###set text search option to specify regular expression usage TextSearchOptions textSearchOptions = new TextSearchOptions(true); textFragmentAbsorber.TextSearchOptions = textSearchOptions; //accept the absorber for all the pages pdfDocument.Pages.Accept(textFragmentAbsorber); //get the extracted text fragments TextFragmentCollection textFragmentCollection = textFragmentAbsorber.TextFragments; //loop through the fragments foreach (TextFragment textFragment in textFragmentCollection) { Console.WriteLine("Text : {0} ", textFragment.Text); //Console.WriteLine("Position : {0} ", textFragment.Position); //Console.WriteLine("XIndent : {0} ", textFragment.Position.XIndent); //Console.WriteLine("YIndent : {0} ", textFragment.Position.YIndent); //Console.WriteLine("Font - Name : {0}", textFragment.TextState.Font.FontName); //Console.WriteLine("Font - IsAccessible : {0} ", textFragment.TextState.Font.IsAccessible); //Console.WriteLine("Font - IsEmbedded : {0} ", textFragment.TextState.Font.IsEmbedded); //Console.WriteLine("Font - IsSubset : {0} ", textFragment.TextState.Font.IsSubset); //Console.WriteLine("Font Size : {0} ", textFragment.TextState.FontSize); //Console.WriteLine("Foreground Color : {0} ", textFragment.TextState.ForegroundColor); } }
/// <summary> /// Search document for Text signature /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Basic Usage] # SearchForText : Search document for Text signature \n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; string fileName = Path.GetFileName(filePath); using (Signature signature = new Signature(filePath)) { TextSearchOptions options = new TextSearchOptions() { AllPages = true, // this value is set by default }; // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); Console.WriteLine($"\nSource document ['{fileName}'] contains following text signature(s)."); // enumerate all signature for output foreach (TextSignature textSignature in signatures) { Console.WriteLine($"Found Text signature at page {textSignature.PageNumber} with type [{textSignature.SignatureImplementation}] and text '{textSignature.Text}'."); } } }
public Task <long> CountFor( string playerId, string opponentId = null, GateWay gateWay = GateWay.Undefined, GameMode gameMode = GameMode.Undefined, int season = 1) { var textSearchOpts = new TextSearchOptions(); var mongoCollection = CreateCollection <Matchup>(); if (string.IsNullOrEmpty(opponentId)) { return(mongoCollection.CountDocumentsAsync(m => Builders <Matchup> .Filter.Text($"\"{playerId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (m.Season == season))); } return(mongoCollection.CountDocumentsAsync(m => Builders <Matchup> .Filter.Text($"\"{playerId}\" \"{opponentId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (m.Season == season))); }
/// <summary> /// Search document and cancel process /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Advanced Usage] # CancellationSearchProcess : Search document and cancel process\n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; using (Signature signature = new Signature(filePath)) { signature.SearchProgress += OnSearchProgress; TextSearchOptions options = new TextSearchOptions("Text signature") { // ... }; // search for signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); Console.WriteLine("\nSource document contains following signatures."); foreach (var textSignature in signatures) { Console.WriteLine("Text signature found at page {0} with text {1}", textSignature.PageNumber, textSignature.Text); } } }
public Task <long> CountFor( string playerId, string opponentId = null, GateWay gateWay = GateWay.Undefined, GameMode gameMode = GameMode.Undefined, Race playerRace = Race.Total, Race opponentRace = Race.Total, int season = 1) { var textSearchOpts = new TextSearchOptions(); var mongoCollection = CreateCollection <Matchup>(); if (string.IsNullOrEmpty(opponentId)) { return(mongoCollection.CountDocumentsAsync(m => Builders <Matchup> .Filter.Text($"\"{playerId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (playerRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == playerRace && playerId == team.Players[0].BattleTag)) && (opponentRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == opponentRace && playerId != team.Players[0].BattleTag)) && (m.Season == season))); } return(mongoCollection.CountDocumentsAsync(m => Builders <Matchup> .Filter.Text($"\"{playerId}\" \"{opponentId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (m.Season == season))); }
public static void Run() { // ExStart:SearchTextAndDrawRectangle // The path to the documents directory. string dataDir = RunExamples.GetDataDir_AsposePdf_Text(); // Open document Document document = new Document(dataDir + "SearchAndGetTextFromAll.pdf"); // Create TextAbsorber object to find all the phrases matching the regular expression TextFragmentAbsorber textAbsorber = new TextFragmentAbsorber(@"[\S]+"); TextSearchOptions textSearchOptions = new TextSearchOptions(true); textAbsorber.TextSearchOptions = textSearchOptions; document.Pages.Accept(textAbsorber); var editor = new PdfContentEditor(document); foreach (TextFragment textFragment in textAbsorber.TextFragments) { foreach (TextSegment textSegment in textFragment.Segments) { DrawBox(editor, textFragment.Page.Number, textSegment, System.Drawing.Color.Red); } } dataDir = dataDir + "SearchTextAndDrawRectangle_out.pdf"; document.Save(dataDir); // ExEnd:SearchTextAndDrawRectangle Console.WriteLine("\nRectangle drawn successfully on searched text.\nFile saved at " + dataDir); }
/// <summary> /// 全文检索 /// </summary> /// <param name="key"></param> /// <param name="caseSensitive"></param> /// <param name="diacriticSensitive"></param> /// <param name="limit"></param> /// <param name="language"></param> /// <returns></returns> public static List <BsonDocument> SearchText(string key, bool caseSensitive, bool diacriticSensitive, int limit, string language = "") { //检索文法: //[Before2.6]http://docs.mongodb.org/manual/reference/command/text/#text-search-languages //[After 2.6]http://docs.mongodb.org/manual/reference/operator/query/text/#op._S_text //[From 3.2]https://docs.mongodb.org/master/reference/operator/query/text/ //{ // $text: // { // $search: < string >, // $language: < string >, // $caseSensitive: < boolean >, // $diacriticSensitive: < boolean > // } //} //检索关键字 var textSearchOption = new TextSearchOptions(); textSearchOption.CaseSensitive = caseSensitive; textSearchOption.DiacriticSensitive = diacriticSensitive; //语言 if (string.IsNullOrEmpty(language)) { textSearchOption.Language = language; } var textSearchQuery = Query.Text(key, textSearchOption); var result = RuntimeMongoDbContext.GetCurrentCollection().FindAs <BsonDocument>(textSearchQuery); var resultDocumentList = result.SetLimit(limit).ToList(); return(resultDocumentList); }
/// <summary> /// Delete Text signature from the document. /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Basic Usage] # DeleteText : Delete Text signature from the document \n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; string fileName = Path.GetFileName(filePath); // copy source file since Delete method works with same Document string outputFilePath = Path.Combine(Constants.OutputPath, "DeleteText", fileName); Constants.CheckDir(outputFilePath); File.Copy(filePath, outputFilePath, true); using (Signature signature = new Signature(outputFilePath)) { TextSearchOptions options = new TextSearchOptions(); // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); if (signatures.Count > 0) { TextSignature textSignature = signatures[0]; bool result = signature.Delete(textSignature); if (result) { Console.WriteLine($"Signature with Text '{textSignature.Text}' was deleted from document ['{fileName}']."); } else { Helper.WriteError($"Signature was not deleted from the document! Signature with Text '{textSignature.Text}' was not found!"); } } } }
/// <summary> /// Delete multiple signatures from the document /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Basic Usage] # DeleteMultiple : Delete multiple signatures from the document \n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; string fileName = Path.GetFileName(filePath); // copy source file since Delete method works with same Document string outputFilePath = Path.Combine(Constants.OutputPath, "DeleteMultiple", fileName); Constants.CheckDir(outputFilePath); File.Copy(filePath, outputFilePath, true); // processing signatures using (Signature signature = new Signature(outputFilePath)) { // define few search options TextSearchOptions textSearchOptions = new TextSearchOptions(); ImageSearchOptions imageSearchOptions = new ImageSearchOptions(); BarcodeSearchOptions barcodeOptions = new BarcodeSearchOptions(); QrCodeSearchOptions qrCodeOptions = new QrCodeSearchOptions(); // add options to list List <SearchOptions> listOptions = new List <SearchOptions>(); listOptions.Add(textSearchOptions); listOptions.Add(imageSearchOptions); listOptions.Add(barcodeOptions); listOptions.Add(qrCodeOptions); // search for signatures in document SearchResult result = signature.Search(listOptions); if (result.Signatures.Count > 0) { Console.WriteLine("\nTrying to delete all signatures..."); DeleteResult deleteResult = signature.Delete(result.Signatures); if (deleteResult.Succeeded.Count == result.Signatures.Count) { Console.WriteLine("\nAll signatures were successfully deleted!"); } else { Console.WriteLine($"Successfully deleted signatures : {deleteResult.Succeeded.Count}"); Helper.WriteError($"Not deleted signatures : {deleteResult.Failed.Count}"); } Console.WriteLine("\nList of deleted signatures:"); int number = 1; foreach (BaseSignature temp in deleteResult.Succeeded) { Console.WriteLine($"Signature #{number++}: Type: {temp.SignatureType} Id:{temp.SignatureId}, Location: {temp.Left}x{temp.Top}. Size: {temp.Width}x{temp.Height}"); } } else { Helper.WriteError("No one signature was found."); } } }
/// <summary> /// Searches the control tree and returns the first match /// </summary> /// <param name="expression"> /// The search expression <see cref="System.String"/> /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <param name="recursive"> /// Search in all the subtree if true /// </param> /// <returns> /// A <see cref="Control"/> that matches the expression /// </returns> public Control FindFirst(string expression, TextSearchOptions searchOptions, bool recursive) { IFullList <Control> res = Find(expression, searchOptions, recursive, true); if (res.Count > 0) { return(res[0]); } return(null); }
protected override TextSearchResult Search(SearchContext context) { string regex = GetMultiWordRegex(context.Text); TextSearchOptions regexOptions = new TextSearchOptions { UseRegularExpression = true }; SearchContext newContext = new SearchContext(context.PdfViewer, context.Document, regex, regexOptions, context.SearchProgress, context.CancellationToken); return(base.Search(newContext)); }
public void TestTextWithOptionsQueryGeneration() { var options = new TextSearchOptions { Language = "norwegian", CaseSensitive = true, DiacriticSensitive = true }; var query = Query.Text("foo", options); var expected = "{ \"$text\" : { \"$search\" : \"foo\", \"$language\" : \"norwegian\", \"$caseSensitive\" : true, \"$diacriticSensitive\" : true } }"; Assert.AreEqual(expected, query.ToJson()); }
/// <summary> /// Update Text signature in the document. /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Advanced Usage] # UpdateTextAfterSearch : Update Text signature in the document\n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; // copy source file since Update method works with same Document string fileName = Path.GetFileName(filePath); string outputFilePath = Path.Combine(Constants.OutputPath, "UpdateTextAfterSearch", fileName); Constants.CheckDir(outputFilePath); File.Copy(filePath, outputFilePath, true); // using (Signature signature = new Signature(outputFilePath)) { TextSearchOptions options = new TextSearchOptions(); // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); // adjust signature properties foreach (TextSignature temp in signatures) { // apply some condition to adjust signature properties if (temp.Text == "Text signature") { temp.Left = temp.Left + 100; temp.Top = temp.Top + 100; temp.Text = "Mr. John Smith"; } temp.IsSignature = true; } // update all found signatures UpdateResult updateResult = signature.Update(signatures.ConvertAll(p => (BaseSignature)p)); if (updateResult.Succeeded.Count == signatures.Count) { Console.WriteLine("\nAll signatures were successfully updated!"); } else { Console.WriteLine($"Successfully updated signatures : {updateResult.Succeeded.Count}"); Helper.WriteError($"Not updated signatures : {updateResult.Failed.Count}"); } Console.WriteLine("List of updated signatures:"); foreach (BaseSignature temp in updateResult.Succeeded) { Console.WriteLine($"Signature# Id:{temp.SignatureId}, Location: {temp.Left}x{temp.Top}. Size: {temp.Width}x{temp.Height}"); } } }
public bool isNameExist(string name, bool isAll) { TextSearchOptions option = new TextSearchOptions(); option.CaseSensitive = false; FilterDefinition <repairmanTable> queryFilter = Builders <repairmanTable> .Filter.Text(name, option); if (!isAll) { queryFilter &= defaultFilter; } var recordCount = collection.Find(queryFilter).Count(); return(recordCount > 0); }
public async Task <IEnumerable <DataTag> > GetDataTagSuggestions(string q) { var options = new TextSearchOptions(); options.CaseSensitive = false; options.Language = "en"; var regexFilter = Builders <DataTag> .Filter.Regex(x => x.Value, new BsonRegularExpression(q, "i")); var textFilter = Builders <DataTag> .Filter.Text(q, options); var result = await Collection.Find(Builders <DataTag> .Filter.Or(textFilter, regexFilter)).Limit(20).ToListAsync(); return(result); }
/// <summary> /// Delete Text signature from the document. /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Advanced Usage] # DeleteTextAfterSearch : Delete Text signature from the document\n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; // copy source file since Delete method works with same Document string fileName = Path.GetFileName(filePath); string outputFilePath = Path.Combine(Constants.OutputPath, "DeleteTextAfterSearch", fileName); Constants.CheckDir(outputFilePath); File.Copy(filePath, outputFilePath, true); // initialize Signature instance using (Signature signature = new Signature(outputFilePath)) { TextSearchOptions options = new TextSearchOptions(); List <TextSignature> signatures = signature.Search <TextSignature>(options); List <BaseSignature> signaturesToDelete = new List <BaseSignature>(); // collect signatures to delete foreach (TextSignature temp in signatures) { if (temp.Text.Contains("Text signature")) { signaturesToDelete.Add(temp); } } // delete signatures DeleteResult deleteResult = signature.Delete(signaturesToDelete); if (deleteResult.Succeeded.Count == signaturesToDelete.Count) { Console.WriteLine("All signatures were successfully deleted!"); } else { Console.WriteLine($"Successfully deleted signatures : {deleteResult.Succeeded.Count}"); Helper.WriteError($"Not deleted signatures : {deleteResult.Failed.Count}"); } Console.WriteLine("List of deleted signatures:"); foreach (BaseSignature temp in deleteResult.Succeeded) { Console.WriteLine($"Signature# Id:{temp.SignatureId}, Location: {temp.Left}x{temp.Top}. Size: {temp.Width}x{temp.Height}"); } } }
private void wrapAroundToolStripMenuItem_CheckedChanged(object sender, EventArgs e) { if (wrapAroundToolStripMenuItem.Checked) { if (!textSearchOptions.HasFlag(TextSearchOptions.WrapAround)) { textSearchOptions |= TextSearchOptions.WrapAround; } } else { if (textSearchOptions.HasFlag(TextSearchOptions.WrapAround)) { textSearchOptions &= ~TextSearchOptions.WrapAround; } } }
private void caseSensitiveToolStripMenuItem_CheckedChanged(object sender, EventArgs e) { if (caseSensitiveToolStripMenuItem.Checked) { if (!textSearchOptions.HasFlag(TextSearchOptions.CaseSensitive)) { textSearchOptions |= TextSearchOptions.CaseSensitive; } } else { if (textSearchOptions.HasFlag(TextSearchOptions.CaseSensitive)) { textSearchOptions &= ~TextSearchOptions.CaseSensitive; } } }
public async ValueTask <IPaginationCollection <TModel> > SearchAsync( string membershipId, string keyword, int?skip = null, int?limit = null, bool?withCount = null, string sortField = null, SortDirection?sortDirection = null) { var membership = await this.membershipService.GetAsync(membershipId); if (membership == null) { throw ErtisAuthException.MembershipNotFound(membershipId); } var textSearchLanguage = TextSearchLanguage.None; if (!string.IsNullOrEmpty(membership.DefaultLanguage) && TextSearchLanguage.All.Any(x => x.ISO6391Code == membership.DefaultLanguage)) { textSearchLanguage = TextSearchLanguage.All.FirstOrDefault(x => x.ISO6391Code == membership.DefaultLanguage); } var textSearchOptions = new TextSearchOptions { Language = textSearchLanguage, IsCaseSensitive = true, IsDiacriticSensitive = false }; var paginatedDtoCollection = await this.repository.SearchAsync(keyword, textSearchOptions, skip, limit, withCount, sortField, sortDirection); if (paginatedDtoCollection?.Items != null) { return(new PaginationCollection <TModel> { Items = paginatedDtoCollection.Items.Select(x => Mapper.Current.Map <TDto, TModel>(x)), Count = paginatedDtoCollection.Count }); } else { return(new PaginationCollection <TModel>()); } }
public static void Run() { // The path to the documents directory. string dataDir = RunExamples.GetDataDir_AsposePdf_Text(); //open document Document pdfDocument = new Document(dataDir + "SearchRegularExpressionPage.pdf"); //create TextAbsorber object to find all the phrases matching the regular expression TextFragmentAbsorber textFragmentAbsorber = new TextFragmentAbsorber("\\d{4}-\\d{4}"); //like 1999-2000 //set text search option to specify regular expression usage TextSearchOptions textSearchOptions = new TextSearchOptions(true); textFragmentAbsorber.TextSearchOptions = textSearchOptions; //accept the absorber for a single page pdfDocument.Pages[1].Accept(textFragmentAbsorber); //get the extracted text fragments TextFragmentCollection textFragmentCollection = textFragmentAbsorber.TextFragments; //loop through the fragments foreach (TextFragment textFragment in textFragmentCollection) { Console.WriteLine("Text : {0} ", textFragment.Text); Console.WriteLine("Position : {0} ", textFragment.Position); Console.WriteLine("XIndent : {0} ", textFragment.Position.XIndent); Console.WriteLine("YIndent : {0} ", textFragment.Position.YIndent); Console.WriteLine("Font - Name : {0}", textFragment.TextState.Font.FontName); Console.WriteLine("Font - IsAccessible : {0} ", textFragment.TextState.Font.IsAccessible); Console.WriteLine("Font - IsEmbedded : {0} ", textFragment.TextState.Font.IsEmbedded); Console.WriteLine("Font - IsSubset : {0} ", textFragment.TextState.Font.IsSubset); Console.WriteLine("Font Size : {0} ", textFragment.TextState.FontSize); Console.WriteLine("Foreground Color : {0} ", textFragment.TextState.ForegroundColor); } }
public IEnumerable <Contact> Get(string query) { // Try a faster search on text index first var options = new TextSearchOptions { CaseSensitive = false, DiacriticSensitive = false }; var indexQuery = Builders <Contact> .Filter.Text(query, options); var indexResult = _contacts.Find(indexQuery); if (indexResult.Any()) { return(indexResult.ToList()); } // If that produces no results, search more precise instead return(_contacts.Find(queryFilter(query)).ToList()); }
/// <summary> /// 全文检索 /// </summary> /// <param name="collectionName"></param> /// <param name="key"></param> /// <param name="caseSensitive"></param> /// <param name="limit"></param> /// <returns></returns> public static List <BsonDocument> SearchText(string collectionName, string key, bool caseSensitive, int limit, IMongoQuery query = null) { //检索关键字 var textSearchOption = new TextSearchOptions(); textSearchOption.CaseSensitive = caseSensitive; var textSearchQuery = Query.Text(key, textSearchOption); if (query != null) { textSearchQuery = Query.And(textSearchQuery, query); } MongoCollection col = GetDatabaseByType(_defaultDatabaseName).GetCollection(collectionName); var result = col.FindAs <BsonDocument>(textSearchQuery); var resultDocumentList = result.SetLimit(limit).ToList(); return(resultDocumentList); }
/// <summary> /// Update Text signature in the document. /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Basic Usage] # UpdateText : Update Text signature in the document \n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; // copy source file since Update method works with same Document string fileName = Path.GetFileName(filePath); string outputFilePath = Path.Combine(Constants.OutputPath, "UpdateText", fileName); Constants.CheckDir(outputFilePath); File.Copy(filePath, outputFilePath, true); // using (Signature signature = new Signature(outputFilePath)) { TextSearchOptions options = new TextSearchOptions(); // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); if (signatures.Count > 0) { TextSignature textSignature = signatures[0]; // change Text property textSignature.Text = "John Walkman"; // change position textSignature.Left = textSignature.Left + 10; textSignature.Top = textSignature.Top + 10; // change size. Please note not all documents support changing signature size textSignature.Width = 200; textSignature.Height = 100; bool result = signature.Update(textSignature); if (result) { Console.WriteLine($"Signature with Text '{textSignature.Text}' was updated in the document ['{fileName}']."); } else { Helper.WriteError($"Signature was not updated in the document! Signature with Text '{textSignature.Text}' was not found!"); } } } }
/// <summary> /// Search document for Text signature /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Advanced Usage] # SearchForTextAdvanced : Search document for Text signature\n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; using (Signature signature = new Signature(filePath)) { TextSearchOptions options = new TextSearchOptions() { // specify special pages to search on AllPages = false, // single page number PageNumber = 1, // setup extended search in pages setup PagesSetup = new PagesSetup() { FirstPage = true, LastPage = true, OddPages = false, EvenPages = false }, // specify text match type MatchType = TextMatchType.Exact, // specify text pattern to search Text = "Text signature" }; // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); Console.WriteLine("\nSource document contains following text signature(s)."); // enumerate all signature for output foreach (TextSignature textSignature in signatures) { if (textSignature != null) { Console.WriteLine($"Found Text signature at page {textSignature.PageNumber} with type [{textSignature.SignatureImplementation}] and text '{textSignature.Text}'."); Console.WriteLine($"Location at {textSignature.Left}-{textSignature.Top}. Size is {textSignature.Width}x{textSignature.Height}."); } } } }
public async Task <List <Matchup> > LoadFor( string playerId, string opponentId = null, GateWay gateWay = GateWay.Undefined, GameMode gameMode = GameMode.Undefined, Race playerRace = Race.Total, Race opponentRace = Race.Total, int pageSize = 100, int offset = 0, int season = 1) { var mongoCollection = CreateCollection <Matchup>(); var textSearchOpts = new TextSearchOptions(); if (string.IsNullOrEmpty(opponentId)) { return(await mongoCollection .Find(m => Builders <Matchup> .Filter.Text($"\"{playerId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (playerRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == playerRace && playerId == team.Players[0].BattleTag)) && (opponentRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == opponentRace && playerId != team.Players[0].BattleTag)) && (m.Season == season)) .SortByDescending(s => s.Id) .Skip(offset) .Limit(pageSize) .ToListAsync()); } return(await mongoCollection .Find(m => Builders <Matchup> .Filter.Text($"\"{playerId}\" \"{opponentId}\"", textSearchOpts).Inject() && (gameMode == GameMode.Undefined || m.GameMode == gameMode) && (gateWay == GateWay.Undefined || m.GateWay == gateWay) && (m.Season == season)) .SortByDescending(s => s.Id) .Skip(offset) .Limit(pageSize) .ToListAsync()); }
public static void Run() { // ExStart:ReplaceTextonRegularExpression // The path to the documents directory. string dataDir = RunExamples.GetDataDir_AsposePdf_Text(); // Open document Document pdfDocument = new Document(dataDir + "SearchRegularExpressionPage.pdf"); // Create TextAbsorber object to find all the phrases matching the regular expression TextFragmentAbsorber textFragmentAbsorber = new TextFragmentAbsorber("\\d{4}-\\d{4}"); //like 1999-2000 // Set text search option to specify regular expression usage TextSearchOptions textSearchOptions = new TextSearchOptions(true); textFragmentAbsorber.TextSearchOptions = textSearchOptions; // Accept the absorber for a single page pdfDocument.Pages[1].Accept(textFragmentAbsorber); // Get the extracted text fragments TextFragmentCollection textFragmentCollection = textFragmentAbsorber.TextFragments; // Loop through the fragments foreach (TextFragment textFragment in textFragmentCollection) { // Update text and other properties textFragment.Text = "New Phrase"; // Set to an instance of an object. textFragment.TextState.Font = FontRepository.FindFont("Verdana"); textFragment.TextState.FontSize = 22; textFragment.TextState.ForegroundColor = Aspose.Pdf.Color.FromRgb(System.Drawing.Color.Blue); textFragment.TextState.BackgroundColor = Aspose.Pdf.Color.FromRgb(System.Drawing.Color.Green); } dataDir = dataDir + "ReplaceTextonRegularExpression_out_.pdf"; pdfDocument.Save(dataDir); // ExEnd:ReplaceTextonRegularExpression Console.WriteLine("\nText replaced successfully based on a regular expression.\nFile saved at " + dataDir); }
public static void Run() { // ExStart:ReplaceTextonRegularExpression // The path to the documents directory. string dataDir = RunExamples.GetDataDir_AsposePdf_Text(); // Open document Document pdfDocument = new Document(dataDir + "SearchRegularExpressionPage.pdf"); // Create TextAbsorber object to find all the phrases matching the regular expression TextFragmentAbsorber textFragmentAbsorber = new TextFragmentAbsorber("\\d{4}-\\d{4}"); // Like 1999-2000 // Set text search option to specify regular expression usage TextSearchOptions textSearchOptions = new TextSearchOptions(true); textFragmentAbsorber.TextSearchOptions = textSearchOptions; // Accept the absorber for a single page pdfDocument.Pages[1].Accept(textFragmentAbsorber); // Get the extracted text fragments TextFragmentCollection textFragmentCollection = textFragmentAbsorber.TextFragments; // Loop through the fragments foreach (TextFragment textFragment in textFragmentCollection) { // Update text and other properties textFragment.Text = "New Phrase"; // Set to an instance of an object. textFragment.TextState.Font = FontRepository.FindFont("Verdana"); textFragment.TextState.FontSize = 22; textFragment.TextState.ForegroundColor = Aspose.Pdf.Color.FromRgb(System.Drawing.Color.Blue); textFragment.TextState.BackgroundColor = Aspose.Pdf.Color.FromRgb(System.Drawing.Color.Green); } dataDir = dataDir + "ReplaceTextonRegularExpression_out.pdf"; pdfDocument.Save(dataDir); // ExEnd:ReplaceTextonRegularExpression Console.WriteLine("\nText replaced successfully based on a regular expression.\nFile saved at " + dataDir); }
/// <summary> /// Search document for Text signature skipping external signatures /// </summary> public static void Run() { Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------"); Console.WriteLine("[Example Advanced Usage] # SearchAndSkipExternalSignatures : Search document for Text signature skipping external signatures\n"); // The path to the documents directory. string filePath = Constants.SAMPLE_SIGNED_MULTI; using (Signature signature = new Signature(filePath)) { TextSearchOptions options = new TextSearchOptions() { // specify search on all pages AllPages = false }; // search for text signatures in document List <TextSignature> signatures = signature.Search <TextSignature>(options); Console.WriteLine($"\nSource document ['{filePath}'] contains following signatures."); // enumerate all signature for output foreach (TextSignature textSignature in signatures) { if (textSignature != null) { Console.WriteLine($"Found Text signature at page {textSignature.PageNumber} with type [{textSignature.SignatureImplementation}] and text '{textSignature.Text}'."); Console.WriteLine($"Location at {textSignature.Left}-{textSignature.Top}. Size is {textSignature.Width}x{textSignature.Height}."); } } // specify SkipExternal value to exclude non signature objects from Search result options.SkipExternal = true; // search for text signatures in document skipping external signatures = signature.Search <TextSignature>(options); Console.WriteLine($"\nSource document ['{filePath}'] contains {signatures.Count} not external signatures."); } }
public async ValueTask <IPaginationCollection <TModel> > SearchAsync( string keyword, TextSearchOptions options = null, int?skip = null, int?limit = null, bool?withCount = null, string sortField = null, SortDirection?sortDirection = null) { var paginatedDtoCollection = await this.repository.SearchAsync(keyword, options, skip, limit, withCount, sortField, sortDirection); if (paginatedDtoCollection?.Items != null) { return(new PaginationCollection <TModel> { Items = paginatedDtoCollection.Items.Select(x => Mapper.Current.Map <TDto, TModel>(x)), Count = paginatedDtoCollection.Count }); } else { return(new PaginationCollection <TModel>()); } }
public FindNextCommand(FixedDocumentViewerBase viewer, TextSearchOptions textSearchOptions) : base(viewer, textSearchOptions) { }
public static TextBlock FindTextBlock(List<TextBlock> block, string toSearch, TextSearchOptions option) { var culture = new CultureInfo(string.Empty); // <- Invariant culture return ( from item in block where (option == TextSearchOptions.StartsWith && item.Text.StartsWith(toSearch, StringComparison.InvariantCultureIgnoreCase)) || (option == TextSearchOptions.Contains && culture.CompareInfo.IndexOf(item.Text, toSearch, CompareOptions.IgnoreCase) > -1) || (option == TextSearchOptions.ExactMatch && string.Equals(item.Text, toSearch, StringComparison.CurrentCultureIgnoreCase)) select item).FirstOrDefault(); }
public static TextBlock FindTextBlock(List<List<TextBlock>> blockList, string toSearch, TextSearchOptions option) { return (from block in blockList select FindTextBlock(block, toSearch, option)).FirstOrDefault(); }
/// <summary> /// Finds the specified expression. /// </summary> /// <param name="expression">The expression.</param> /// <param name="searchOptions">The search options.</param> /// <param name="recursive">if set to <c>true</c> [recursive].</param> /// <returns></returns> public IFullList<Control> Find(string expression, TextSearchOptions searchOptions, bool recursive) { return Find(expression, searchOptions, recursive, false); }
/// <summary> /// Searches the control tree recursively and returns the first match /// </summary> /// <param name="expression"> /// The search expression <see cref="System.String"/> /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <returns> /// A <see cref="Control"/> that matches the expression /// </returns> public Control FindFirst(string expression, TextSearchOptions searchOptions) { return FindFirst(expression, searchOptions, true); }
public FindCommandBase(FixedDocumentViewerBase viewer, TextSearchOptions textSearchOptions) { this.viewer = viewer; this.textSearchOptions = textSearchOptions; }
/// <summary> /// Finds the specified expression. /// </summary> /// <param name="expression">The expression.</param> /// <param name="searchOptions">The search options.</param> /// <returns></returns> public IFullList<Control> Find(string expression, TextSearchOptions searchOptions) { return Find(expression, searchOptions, true); }
/// <summary> /// Searches the control tree and returns the first match /// </summary> /// <param name="rootControl"> /// The root <see cref="Control"/> /// </param> /// <param name="expression"> /// The search expression <see cref="System.String"/> /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <param name="recursive"> /// Search in all the subtree if true /// </param> /// <returns> /// </returns> public static Control FindFirstInControl(Control rootControl, string expression, TextSearchOptions searchOptions, bool recursive) { return new ControlFinder(rootControl).FindFirst(expression, searchOptions, recursive); }
private IFullList<Control> Find(string expression, TextSearchOptions searchOptions, bool recursive, bool stopAtFirst) { bool caseInsensitive = (searchOptions & TextSearchOptions.CaseInsensitive) != 0; IFullList<Control> result = new FullList<Control>(); if ((searchOptions & TextSearchOptions.Regex) == 0) { bool partial = (searchOptions & TextSearchOptions.Partial) != 0; // text if (caseInsensitive) { // case insensitive text expression = expression.ToUpperInvariant(); if (partial) { // case insensitive partial text doFind(root, result, delegate(Control c) { string test = c.ID; if (string.IsNullOrEmpty(test)) return false; test = test.ToUpperInvariant(); return (test.Contains(expression)); }, recursive, stopAtFirst); } else { // case insensitive exact text doFind(root, result, delegate(Control c) { return (string.Compare(c.ID, expression, StringComparison.OrdinalIgnoreCase) == 0); }, recursive, stopAtFirst); } } else { // case sensitive text if (partial) { // case sensitive partial text doFind(root, result, delegate(Control c) { return (c.ID.Contains(expression)); }, recursive, stopAtFirst); } else { // case sensitive exact text doFind(root, result, delegate(Control c) { return (string.Compare(c.ID, expression, StringComparison.Ordinal) == 0); }, recursive, stopAtFirst); } } } else { // regex // we silently ignore the partial flag RegexOptions opts = caseInsensitive ? RegexOptions.IgnoreCase : RegexOptions.None; doFind(root, result, delegate(Control c) { return (Regex.IsMatch(c.ID, expression, opts)); }, recursive, stopAtFirst); } return result; }
/// <summary> /// Finds all controls matching the specified expression /// in the specified control and its subtree. /// </summary> /// <param name="rootControl"> /// The root <see cref="Control"/> /// </param> /// <param name="expression"> /// The expression /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <returns> /// </returns> public static IFullList<Control> FindInControl(Control rootControl, string expression, TextSearchOptions searchOptions) { return FindInControl(rootControl, expression, searchOptions, true); }
/// <summary> /// Builds a lambda expression that can be used in a where clause, /// that searches for the given phrase (considering the search /// options) in the given property name(s) /// /// Eg to search for the exact phrase "This is a test phrase" in the /// field/property "TestField" of some object, you could call /// var res = someCollection.Where(SearchText("This is a test phrase", TextSearchOptions.SearchExact, o=>o.TestField)); /// /// It is important to note that the properties are OR'd together, /// ie the returned expression will return true if the searchPhrase /// is found in ANY of the properties. /// </summary> /// <param name="searchPhrase"></param> /// <param name="opt"></param> /// <param name="fieldsToSearch"></param> /// <returns></returns> public static Expression <Func <MPDrawing, bool> > SearchText(string searchPhrase, TextSearchOptions opt, params Expression <Func <MPDrawing, string> >[] fieldsToSearch) { int numFields = fieldsToSearch.Count(); string[] propNames = new string[numFields]; Expression <Func <MPDrawing, bool> > whereClause = null; Expression <Func <MPDrawing, bool> > whereSubClause = null; //fetch the property names for (int i = 0; i < numFields; i++) { propNames[i] = GPN(fieldsToSearch[i]); } //deal with the SearchExact case if (opt == TextSearchOptions.SeachExact) { whereClause = WhereLike(propNames[0], searchPhrase); for (int j = 1; j < numFields; j++) { whereClause = whereClause.OrElse(WhereLike(propNames[j], searchPhrase)); } return(whereClause); } //tokenise the search phrase string[] tokens = searchPhrase.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); //if there aren't any tokens (eg a string of spaces), just search the exact phrase instead if (tokens.Count() == 0) { return(SearchText(searchPhrase, TextSearchOptions.SeachExact, fieldsToSearch)); } ; //create the clause for the first property whereClause = WhereLike(propNames[0], tokens[0]); for (int i = 1; i < tokens.Length; i++) { whereClause = opt == TextSearchOptions.SearchAllWords ? whereClause.AndAlso(WhereLike(propNames[0], tokens[i])) : whereClause.OrElse(WhereLike(propNames[0], tokens[i])); } //if there are more fields, or them all up for (int j = 1; j < numFields; j++) { whereSubClause = WhereLike(propNames[j], tokens[0]); for (int i = 1; i < tokens.Length; i++) { whereSubClause = opt == TextSearchOptions.SearchAllWords ? whereSubClause.AndAlso(WhereLike(propNames[j], tokens[i])) : whereSubClause.OrElse(WhereLike(propNames[j], tokens[i])); } whereClause = whereClause.OrElse(whereSubClause); } return(whereClause); }
/// <summary> /// Searches the control tree recursively and returns the first match /// </summary> /// <param name="rootControl"> /// The root <see cref="Control"/> /// </param> /// <param name="expression"> /// The search expression <see cref="System.String"/> /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <returns> /// </returns> public static Control FindFirstInControl(Control rootControl, string expression, TextSearchOptions searchOptions) { return FindFirstInControl(rootControl, expression, searchOptions, true); }
public FindDialogViewModel(FindDialogContext context) { this.textSearchOptions = new TextSearchOptions(false, false, false); this.findNextCommand = new FindNextCommand(context.FixedDocumentViewer, this.TextSearchOptions); this.findPreviousCommand = new FindPreviousCommand(context.FixedDocumentViewer, this.TextSearchOptions); }
/// <summary> /// Finds all controls matching the specified expression /// </summary> /// <param name="rootControl"> /// The root <see cref="Control"/> /// </param> /// <param name="expression"> /// The expression /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <param name="recursive"> /// Recurse subtree if true /// </param> /// <returns> /// </returns> public static IFullList<Control> FindInControl(Control rootControl, string expression, TextSearchOptions searchOptions, bool recursive) { return new ControlFinder(rootControl).Find(expression, searchOptions, recursive); }
/// <summary> /// Searches the control tree and returns the first match /// </summary> /// <param name="expression"> /// The search expression <see cref="System.String"/> /// </param> /// <param name="searchOptions"> /// The <see cref="TextSearchOptions"/> /// </param> /// <param name="recursive"> /// Search in all the subtree if true /// </param> /// <returns> /// A <see cref="Control"/> that matches the expression /// </returns> public Control FindFirst(string expression, TextSearchOptions searchOptions, bool recursive) { IFullList<Control> res = Find(expression, searchOptions, recursive, true); if (res.Count > 0) return res[0]; return null; }