DEV Community: GroupDocs

Big News! GroupDocs.Redaction has been released for Java platform!

GroupDocs — Sat, 22 Jun 2019 06:58:58 +0000

Do you have to deal with a frequent exchange of the digital documents? Do your documents contain classified and sensitive information that needs to be protected? If they do, how do you process such documents to hide or remove some specific information before sending them outside your company? Well, these questions will definitely pop out the solution that you are currently using for protecting the sensitive content in your document.

What if I tell you that you can automate the process of protecting the classified content in your documents? Wouldn’t it be great when you will be able to do it for a bunch of documents using a single click?

Yes, you can now redact, hide or remove sensitive content & metadata from word processing documents, worksheets, presentations, PDF and raster image files in your Java applications using GroupDocs.Redaction for Java.‎ The API provides a single ‎format-independent interface supporting various redaction types such as text redaction, metadata ‎redaction, annotation redaction, and tabular document redaction. Read more: http://bit.ly/2J4dtDB

Save Assembled Word Processing, Presentation, Spreadsheet and Email Documents as HTML

GroupDocs — Wed, 19 Jun 2019 16:28:12 +0000

Imagine a scenario where you have some Word documents created in MS Word and you want to display them in your web application. So how would you view the content of the file? A suitable and easy solution is if you could get the HTML form of the Word document then it can be viewed in the web browser within your application. Isn’t it great when you could view the documents without having installed some Office viewer? Let’s now find out how did we make use of HTML format in making GroupDocs.Assembly more powerful and useful for you.

Since version 19.5, the assembled Word Processing documents, Spreadsheets, Presentations, and Email files could be saved as HTML with external resources. This means that the generated reports can now be saved as HTML files along with the resources such as images and, as I have mentioned before, you would be able to embed and view the content of the generated reports within your web application. Read more – https://bit.ly/2WRtqqc

How to Find Metadata Signatures in Image Files using C# .NET API

GroupDocs — Mon, 18 Feb 2019 06:42:49 +0000

This article covers a brief introduction about the e-signing process; the benefits gained by end users together with a reference to one of the well-known document eSigning APIs for .NET platform.

Electronic signing or e-signing is the procedure of signing your legal, contractual or any other type of documents digitally, without the need to scan or print them. e-Signing helps in reducing the hassle of obtaining hard copies, processing and storing them, together with providing an avenue towards a paper-less environment.

Let’s talk about at which levels is eSigning process required. Is it exclusive to certain departments, businesses or individuals? No, this process has a very broad scope; one might implement it at a personal or enterprise level too.

We can now look at how you can actually eSign your documents. Whether it is a manual or automated procedure? There are no hard and fast rules, individuals can add e-Signatures into their files manually or, there could be an automated approach for batch processing. If you are a programmer and would like to code an app on .NET platform which lets you digitally sign numerous types of files, you can consider using GroupDocs.Signature for .NET API. It supports adding text, image, digital, barcode, QR-code and metadata type signatures into PDF, Microsoft Word, Excel, PowerPoint, Text, JPEG and TIFF files proficiently.

Latest release of this .NET API comes with an interesting feature of searching for metadata signatures inside your .NET based image file formats. Feel free to checkout available features yourself – http://bit.ly/2TRzEAW

Follow GroupDocs on YouTube – http://bit.ly/2PwqUNK

C# .NET API to Redact Classified Information in PDF, Word, Excel and PowerPoint Documents

GroupDocs — Tue, 12 Feb 2019 15:09:31 +0000

Do you frequently send or receive documents electronically? If so, you will be familiar with the importance of protecting sensitive information contained within digitally processed documents. Text encryption, hiding or even removing specific types of information from the documents are few different ways of securing your files.

A question, why would you need to protect this type of information anyways? What’s the big deal? Well, everyone may have his own reasons, depending upon the kind of documents and data in question, key principle stays the same; to be sure that the information being transferred electronically is safe, it isn’t manipulated in any wrong or harmful way.

So, in conclusion, we want to transfer documents over the internet, but we want to be able to protect document contents by any means feasible. Considering it could be cumbersome processing a bunch of files manually, we can use an API which lets us develop apps for hiding or removing sensitive document data and automate the whole process. If you are working on .NET platform, you can leverage the newly launched GroupDocs.Redaction for .NET API. It is a feature rich document redaction API which helps you obscure classified text, metadata or tabular data from document contents, comments and annotations inside your PDF, Microsoft Word, Excel and PowerPoint files. Learn more – http://bit.ly/redact-documents

Follow GroupDocs on YouTube – http://bit.ly/2PwqUNK

Editing Documents in Multi-threaded Environment using C# .NET API

GroupDocs — Mon, 11 Feb 2019 08:16:31 +0000

Editing different types of documents programmatically on different development platforms is almost a given when talking about document manipulation in general. Most basic requirement is to modify file contents, then re-convert the file to original or even a different format too. Add to it some other perks like multiple sources for loading documents, securing the resultant documents and so on.

So, an API offering document editing features plus the document we wish to edit is all we need to get started. If .NET platform is your forte, you can try GroupDocs.Editor for .NET API, which is a feature rich file editor helping you in developing simple, scalable C# and ASP.NET apps which integrate with different HTML based editors to modify your Microsoft Word, Excel, OpenDocument, Text, HTML and other types of documents.

Latest release of this .NET API supports a refined set of lists and paragraphs to use in HTML editors. Additionally, you have access to a more stable multi-threading environment thus allowing you to further enhance your document editing experience.

Following code snippet shows how you can obtain HTML document with along with its embedded resources:
public static void GetHTMLContentsWithEmbeddedResources() { // Obtain document stream Stream sourceStream = File.Open(Path.Combine(Common.sourcePath, Common.sourceFile), FileMode.Open, FileAccess.Read); using (InputHtmlDocument htmlDoc = EditorHandler.ToHtml(sourceStream)) { // Obtain HTML document with embedded resources string cssContent = htmlDoc.GetEmbeddedHtml(); Console.WriteLine(cssContent); } // close stream object to release file for other methods. sourceStream.Close(); }

More help along with sample codes is available at this docs resource - http://bit.ly/2GBKvvk

Similarly, if you are looking to convert HTML DOM to a document, please refer to below code snippet. Which specifically gets HTML DOM from string content and saves it to a document:

public static void GetHTMLDOMContentsToDocument() { // Obtain document stream Stream sourceStream = File.Open(Path.Combine(Common.sourcePath, Common.sourceFile), FileMode.Open, FileAccess.Read); using (InputHtmlDocument htmlDoc = EditorHandler.ToHtml(sourceStream)) { // Obtain HTML document content string htmlContent = htmlDoc.GetContent(); using (OutputHtmlDocument editedHtmlDoc = OutputHtmlDocument.FromMarkup(htmlContent, Path.Combine(Common.sourcePath, Common.resultResourcesFolder))) { using (System.IO.FileStream outputStream = System.IO.File.Create(Path.Combine(Common.resultPath, Common.resultFile))) { WordsSaveOptions saveOptions = new WordsSaveOptions(); EditorHandler.ToDocument(editedHtmlDoc, outputStream, saveOptions); } } } // close stream object to release file for other methods. sourceStream.Close(); }

Try free today – http://bit.ly/2DZY99S

Follow GroupDocs on YouTube – http://bit.ly/2UPmVPr

Implementing Wildcard Search Functionality in your Java Applications

GroupDocs — Thu, 31 Jan 2019 11:59:01 +0000

Indexing is a term quite synonymous with search engines now days, however, by definition, it refers to organizing data based on a specific schema. To put it another way, it’s the process of making data and information more presentable as well as conveniently accessible.

Arrangement of data in an index saves you time and effort during information search or retrieval. For perspective, consider a book on space science containing hundreds of pages. If it does not include an index, you would have to search through the whole book every time you wish to view desired information. It would be a completely different scenario with this book having an index, you can open the exact page which holds the information you are looking for.

As a programmer, you may come across a business requirement of data indexing in certain types of documents. It would require creating a sophisticated schema allowing you to not only index information seamlessly, but also perform search operations where required. Add to it the need to execute all this on Java platform and you would require an API offering:

Support for multi-format documents
Ability to create multiple indices
Capability of several types of search

GroupDocs.Search for Java is a unique indexing API fulfilling aforementioned requisites by providing a refined feature set and flexible structure. It lets Java app developers create and manage multiple indices and use various search queries such as simple, boolean, regular expression (regex) or fuzzy search.

You can use blended characters with this Java API which help you in utilizing characters like a hyphen as valid letters and separators when indexing. Wildcard search option is another very useful feature of this API. There are two forms of wildcards available, single arbitrary character or a range of wildcard arbitrary characters.

Following code snippet shows how to perform wildcard search using text query:
// Creating index Index index = new Index(Utilities.INDEX_PATH,true); // Adding documents to index index.addToIndex(Utilities.DOCUMENTS_PATH,true); // Searching for words 'affect' or 'effect' in a one document with 'principal', 'principle', 'principles', or 'principally' SearchResults results1 = index.search("?ffect & princip?(2~4)"); // Searching with a single query for phrases 'assure equal opportunities', 'ensure equal opportunities', and 'sure equal opportunities' SearchResults results2 = index.search("\"?(0~2)sure equal opportunities\"");

And to search wildcards using object, refer to below code snippet:
// Creating index Index index = new Index(Utilities.INDEX_PATH,true); // Adding documents to index index.addToIndex(Utilities.DOCUMENTS_PATH, true); // Constructing query 1 // Word 1 in the query is a pattern '?ffect' for wildcard search WordPattern pattert11 = new WordPattern(); pattert11.appendOneCharacterWildcard(); pattert11.appendString("ffect"); SearchQuery subquery11 = SearchQuery.createWordPatternQuery(pattert11); // Word 2 in the query is a pattern 'princip?(2~4)' for wildcard search WordPattern pattert12 = new WordPattern(); pattert12.appendString("princip"); pattert12.appendWildcard(2, 4); SearchQuery subquery12 = SearchQuery.createWordPatternQuery(pattert12); // Creating boolean search query SearchQuery query1 = SearchQuery.createAndQuery(subquery11, subquery12); // Searching with query 1 SearchResults results1 = index.search(query1, new SearchParameters()); // Constructing query 2 // Word 1 in the phrase is a pattern '?(0~2)sure' for wildcard search WordPattern pattert21 = new WordPattern(); pattert21.appendWildcard(0, 2); pattert21.appendString("sure"); SearchQuery subquery21 = SearchQuery.createWordPatternQuery(pattert21); // Word 2 in the phrase is searched with different word forms ('equal', 'equals', 'equally', etc.) SearchQuery subquery22 = SearchQuery.createWordQuery("equal"); subquery22.setSearchParameters(new SearchParameters()); subquery22.getSearchParameters().setUseWordFormsSearch(true); // Word 3 in the phrase is searched with maximum 2 differences of fuzzy search SearchQuery subquery23 = SearchQuery.createWordQuery("opportunities"); subquery23.setSearchParameters(new SearchParameters()); subquery23.getSearchParameters().getFuzzySearch().setEnabled(true); subquery23.getSearchParameters().getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(2)); // Creating phrase search query SearchQuery query2 = SearchQuery.createPhraseSearchQuery(subquery21, subquery22, subquery23); // Searching with query 2 SearchResults results2 = index.search(query2, new SearchParameters());

Check all available features yourself today – http://bit.ly/2TmhZRO

Learn to Dynamically Assemble External Documents on .NET Platform using C# .NET API

GroupDocs — Mon, 28 Jan 2019 13:12:46 +0000

Process automation is an upward trend, something we will be depending upon a lot in coming years. It encapsulates a wide ranging, far reaching concept, not just the idea of making things less ‘human dependent’. It refers to increased productivity, to time efficient processing, to better management, to fewer errors, to reliable output and so much more.

Based on the industry or specific business scenario, process automation could take numerous shapes and forms. How about home automation for an example? Wouldn’t you like a nice birthday greeting played to you on your cake day? What about turning your air conditioner on with a voice command? Or, automatically moving your window blinds up and down based on the time of the day? These are all some basic perks which home automation service providers are marketing around the globe.

It’s not too different when it comes to document automation; you would always appreciate a more efficient, more dependable, less error prone document generation process making your life easier while creating legal, financial, contractual and medical as well as countless other types of documents.

If you are a software developer, and you are looking to programmatically incorporate document automation functionality into your applications on .NET platform, there are not many APIs which offer you the convenience of use bundled with a proven feature set and seamless processing. Of the few APIs you could trust, GroupDocs.Assembly for .NET is surely one to consider.

It envelops a range of very useful functions giving you the edge when assembling various types of commonly used documents formats, from different data sources such as database, JSON, XML, OData and Custom .NET Objects. An important feature of this automation API is the ability to dynamically assemble external documents. This feature is currently available for Microsoft Word and Email formats.

You can work with doc tags, which are placeholders within templates, allowing you to absorb documents at run-time. Using these doc tags, programmers can insert documents dynamically into their reports with the .NET API. Learn more – http://bit.ly/automate-external-documents

Following code snippet shows how to insert external document in Word Processing format:

//Setting up source open document template const String strDocumentTemplate = "Word Templates/Nested External Document.docx"; //Setting up destination open document report const String strDocumentReport = "Word Reports/Nested External Document.docx"; try { //Instantiate DocumentAssembler class DocumentAssembler assembler = new DocumentAssembler(); //Call AssembleDocument to generate Report in open document format assembler.AssembleDocument(CommonUtilities.GetSourceDocument(strDocumentTemplate), CommonUtilities.SetDestinationDocument(strDocumentReport), new DataSourceInfo(DataLayer.GetCustomerData(), "customer")); } catch (Exception ex) { Console.WriteLine(ex.Message); }

Similarly, here's how to insert an external document in Email format:

//Setting up source open document template const String strDocumentTemplate = "Email Templates/Nested External Document.msg"; //Setting up destination open document report const String strDocumentReport = "Email Reports/Nested External Document.msg"; try { //Instantiate DocumentAssembler class DocumentAssembler assembler = new DocumentAssembler(); //Call AssembleDocument to generate Report in open document format assembler.AssembleDocument(CommonUtilities.GetSourceDocument(strDocumentTemplate), CommonUtilities.SetDestinationDocument(strDocumentReport), new DataSourceInfo(DataLayer.GetCustomerData(), "customer")); } catch (Exception ex) { Console.WriteLine(ex.Message); }

For downloading relevant resources to execute above mentioned code snippets, please see - http://bit.ly/2ShtYTy

Modify Page Orientation, Rotate Document Pages in your Java applications

GroupDocs — Tue, 22 Jan 2019 13:11:51 +0000

As an application developer, you may come across a business requirement for building utility application which could work with commonly used document formats. Such applications are especially useful on mobile devices and provide end users with a portable, light weight and swift avenue of document manipulation on the go.

When we talk about utility features, we are considering functionalities like modifying the orientation of document pages (portrait, landscape) as well as rotating document pages and many more. One good example of a utility app is a document scanning and printing application, providing end users with the ability to rotate and orientate file pages which they wish to scan or print.

If you are a Java developer and you plan on incorporating similar features into your applications, consider GroupDocs.Merger for Java. It is a sophisticated document merger API for Java platform empowering you to merge, split or trim Microsoft Word, Excel, PowerPoint, PDF, EPUB, ODT, TXT, Diagram and Note format documents as well as move and swap specific document pages too. You have access to an array of basic and advanced features to absorb into any type of Java applications. Try free – http://bit.ly/2CFFpdU

Looking to utilize blended characters and wildcard search in your apps?

GroupDocs — Fri, 18 Jan 2019 13:56:53 +0000

Building smart, feature-rich and reliable applications on different development platforms for searching through various file types is no easy task. Each end user presents his own unique set of requirements which in itself could present app developers with a new challenge.

Talking about platforms, .NET is a common hunting ground for programmers around the globe to develop software applications of countless different types. For instance, a business application to index and search through data fetched from Microsoft Office and OpenOffice files, ZIP archives, email messages or PDF documents. Indexing process lets you collect, parse and store data for quicker, more accurate searching.

In a given scenario, you might need to work with multiple indices, to index more than one set of retrieved information. Therefore, you can either code a program from scratch yourself, or, you can use a dependable API to help you incorporate its features within the apps you plan to create. GroupDocs.Search for .NET is a text search API offering you necessary leverage to utilize its diverse set of features in your .NET search and indexing applications proficiently.

One of the notable features of this .NET API is the use of blended characters within your apps. The idea of this feature is that such characters help you reduce search terms and when indexed, blended characters get simultaneously interpreted as valid letters as well as separators. For instance, consider marking a hyphen (-) as a blended character, now when you index a term such as ‘green-apple’, it will save you three search terms: ‘green’, ‘apple’ & ‘green-apple’.

Following code snippet demonstrates working with blended characters:

string indexFolder = @"c:\MyIndex"; string documentFolder = @"c:\MyDocuments"; // Creating index Index index = new Index(indexFolder); // Marking hyphen as blended character index.Dictionaries.Alphabet.SetRange(new char[] { '-' }, CharacterType.Blended); // Adding documents to index index.AddToIndex(documentFolder); // Searching for word 'silver-gray' SearchResults results = index.Search("silver-gray");

Another prominent feature is that of searching words containing wildcards; supporting two forms, a single wildcard arbitrary character, or a range of characters.

To check how this feature works, please refer to following code snippet:

string indexFolder = @"c:\MyIndex"; string documentFolder = @"c:\MyDocuments"; // Creating index Index index = new Index(indexFolder); // Adding documents to index index.AddToIndex(documentFolder); // Searching for words 'affect' or 'effect' in a one document with // 'principal', 'principle', 'principles', or 'principally' SearchResults results1 = index.Search("?ffect & princip?(2~4)"); // Searching with a single query for phrases 'assure equal opportunities', // 'ensure equal opportunities', and 'sure equal opportunities' SearchResults results2 = index.Search("\"?(0~2)sure equal opportunities\"");

Learn more - http://bit.ly/2AT9qXi

Assemble your External Documents Dynamically using Java API

GroupDocs — Wed, 16 Jan 2019 14:25:41 +0000

Document automation is not a one dimensional process, but a multi-faceted, collaborative set of harmonized sub-systems functioning together to deliver desired output. Computer programmers and app developers continuously use document assembly applications to automate the file generation process for themselves and their clients. Case scenarios and development platforms could differ, but the key principle remains constant.

An important aspect of document automation is the ability to work with dynamic content. On many occasions, we might need to dynamically consume documents into our applications. When it comes to utilizing this functionality on Java platform, one of the most well-known options is GroupDocs.Assembly for Java API. It supports dynamically assembling external documents within your Java apps for Microsoft Office and Email file formats.

You can incorporate the contents of external documents into your reports dynamically with the help of the doc tags which are placeholders inside a template for a document to be absorbed at run-time. It works by declaring an expression inside a doc tag, which helps load a document to be added dynamically. The expression declared within the doc tag is evaluated and the output is then used to load the document with its content replacing the dog tag.

For more help on how the process works with coding samples, please see - http://bit.ly/2VTB7s9

Learn more – http://bit.ly/2HemeNv

How to manipulate your secure PDF, Words, Excel, PowerPoint Documents using C# .NET Metadata API

GroupDocs — Fri, 11 Jan 2019 14:06:58 +0000

Metadata is considered “data about data” inside a file and programmers manipulate it to store as well as extract different kinds of important information from a specific document which could relate to it’s various characteristics such as the user permissions. File security is one of the primary concerns for any professional, considering the number of times he may have to use online file transfer services regularly. So, we are constantly on the outlook for software applications as well as APIs which are reliable in terms of the data we could manipulate using them, and the type of files they could let us manage.

Depending upon the business requirements of any organization or even an individual user, one or more types of documents could be processed programmatically for fetching valuable information like the file metadata on .NET platform. Add to it the requirement of working with encrypted or password-protected documents, and the list of applications that could fulfil both these pre-requisites is quite small. GroupDocs.Metadata for .NET API is one such option, which covers both aforementioned requirements and offers much more. Application developers can use it to read, write, analyze and erase metadata from different types of protected documents such as Microsoft Word and PDF files, Excel spreadsheets or PowerPoint presentations.

Additionally, this .NET document metadata API allows you to better utilize memory usage while loading or saving word processing and slides documents within your apps together with the ability to update metadata keys in DOC and DOCX file formats. Learn more –
http://bit.ly/2QESWr1

Following code snippet shows how to work with metadata of a password protected PDF document:

LoadOptions loadOptions = new LoadOptions("password"); using (PdfFormat format = new PdfFormat(Common.MapSourceFilePath(protectedFilePath), loadOptions)) { // Working with the password-protected document format.CleanMetadata(); format.Save(Common.MapDestinationFilePath(protectedFilePath)); }

This .NET API supports working with Word formats with less memory consumption. Please note that the DocFormat class implements the IDisposable interface and it's necessary to call the Dispose() method when you're done working with its instance.

Check following code snippets to use less memory while working with Word documents.

using (DocFormat format = new DocFormat(@"d:\input.docx")) { // Working with metadata }

If you are loading a Word document from a stream, it's up to you to close the stream when the file is not needed anymore.

using (Stream stream = File.Open(@"d:\input.doc", FileMode.Open, FileAccess.ReadWrite)) { using (DocFormat format = new DocFormat(stream)) { // Working with metadata } // The stream is still open here }

How to Extract Metadata from Presentation Templates using .NET Parsing API

GroupDocs — Tue, 08 Jan 2019 11:54:13 +0000

When it comes to manipulating documents within your applications, the development options are endless. Organizations around the globe, regardless of the niche, regularly incorporate multitudes of innovative functionalities into each of their business scenarios for improving productivity. Extracting different types of information from multi-format documents is one such requisite. However, one primary concern is the accuracy or validity of the extracted data, not all software applications provide developers with highly accurate data extraction functionality.

Therefore, when looking for applications which could provide you with precise extraction of raw and formatted text as well as metadata from many different types of well-known file formats on .NET platform, GroupDocs.Parser for .NET must be considered. Apart from the basic data extraction features this document text extraction API does provide, app developers can use it for extracting text and metadata from various text and presentation templates with the
help of the latest API version. Another important feature is the ability to programmatically fetch tables from PDF documents within your .NET apps. And while working with this functionality, you can create table bounds manually or let the API identify the layout in automatic mode.

In addition to this, you have access to the features of detecting media type of your password-protected Office OpenXML documents and batch document processing –
http://bit.ly/2QuFPsr

Following code samples show how to extract text and metadata from templates:
// Extracting Text void ExtractText(string fileName) { // Extract a text from the file var text = Extractor.Default.ExtractText(fileName); // Print an extracted text Console.WriteLine(text); } // Extracting Metadata void ExtractMetadata(string fileName) { // Extract metadata from the file var metadata = Extractor.Default.ExtractMetadata(fileName); // Print extracted metadata foreach (var m in metadata) { // Print a metadata key Console.Write(m.Key); Console.Write(": "); // Print a metadata value Console.WriteLine(m.Value); } }

Below code sample shows how to detect media type in password-protected Office OpenXML documents:

// Create load options LoadOptions loadOptions = new LoadOptions(); // Set a password loadOptions.Password = "password"; // Get a default composite media type detector var detector = CompositeMediaTypeDetector.Default; // Create a stream to detect media type by content (not file extension) using (var stream = File.OpenRead(Common.GetFilePath(fileName))) { // Detect a media type var mediaType = detector.Detect(stream, loadOptions); // Print a detected media type Console.WriteLine(mediaType); }