Wordize for .NET

https://docs.wordize.com/
Admin
Wordize for .NET is a powerful, modular product for document processing, allowing users to convert,...
Tokens:56,689
Snippets:385
Trust Score:7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Activate Multiple Wordize Product Licenses

Source: https://docs.wordize.com/getting-started/licensing-and-subscription

This example shows how to activate licenses for multiple Wordize products simultaneously by calling SetLicense for each product's license file. This is essential when using several Wordize modules in a single application, ensuring all required functionalities are licensed.

```csharp
Wordize.Settings.SetLicense("Wordize.Net.lic");
Wordize.Settings.SetLicense("Wordize.Web.Net.lic");
```

--------------------------------

### Install Wordize via NuGet Package Manager Console

Source: https://docs.wordize.com/getting-started/installation

This command installs the main Wordize package using the NuGet Package Manager Console in Visual Studio. It fetches all available modules in evaluation access.

```powershell
Install-Package Wordize
```

--------------------------------

### Convert Document With LayoutOptions Context

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, applying customization through a ConverterContext that includes LayoutOptions. This example hides revision marks and bars.

```csharp
ConverterContext context = new ConverterContext();
context.LayoutOptions.CommentDisplayMode = Layout.CommentDisplayMode.Hide;
context.LayoutOptions.RevisionOptions.ShowRevisionMarks = false;
context.LayoutOptions.RevisionOptions.ShowRevisionBars = false;

Converter.Create(context)
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf")
    .Execute();
```

--------------------------------

### Convert Document to Docx using Standard API

Source: https://docs.wordize.com/conversion

This example shows a basic document conversion using the Standard API, converting a specified input document to a DOCX format. It utilizes the Convert method that takes the input file path and the output file path.

```csharp
var doc = "Document.doc";

Converter.Convert(doc, "ConvertedDocument.1.docx");
```

--------------------------------

### Convert Document From File to File

Source: https://docs.wordize.com/conversion

Basic document conversion from an input file to an output file. Uses the Converter.Create() fluent interface.

```csharp
Converter.Create()
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf")
    .Execute();
```

--------------------------------

### Convert Document from Stream to Images using Standard API

Source: https://docs.wordize.com/conversion

This example demonstrates converting a document read from an input stream into an array of image streams using the Standard API. The output image format is configurable via ImageSaveOptions.

```csharp
using var streamIn = File.OpenRead("Document1.docx");

Stream[] pages = Converter.ConvertToImages(streamIn, new ImageSaveOptions(SaveFormat.Png));
```

--------------------------------

### Install HarfBuzz on Ubuntu

Source: https://docs.wordize.com/text-shaping

This command is used to install the HarfBuzz development library on Ubuntu-based systems, such as Docker images. It ensures that the necessary components for text shaping are available when running Wordize on these environments. This is a system-level dependency.

```bash
RUN apt-get update && apt-get install -y libharfbuzz-dev
```

--------------------------------

### Apply Wordize License from File

Source: https://docs.wordize.com/getting-started/licensing-and-subscription

This code snippet demonstrates how to apply a Wordize license by loading it from a .lic file. Ensure the license file is accessible in the specified path. This method is straightforward for single license applications.

```csharp
Wordize.Settings.SetLicense("Wordize.Net.lic");
```

--------------------------------

### Convert Document From File to Image

Source: https://docs.wordize.com/conversion

Initiates the process to convert a document from a file into an image format. The output is directed to a list of streams, implying each page may be a separate image.

```csharp
List<Stream> outputStreams = new List<Stream>();

// Further .To() calls would specify image format and potentially target streams.
```

--------------------------------

### Apply Wordize License from Stream

Source: https://docs.wordize.com/getting-started/licensing-and-subscription

This code demonstrates loading and applying a Wordize license from a stream, specifically using a MemoryStream populated from a file. This approach offers more flexibility in how license data is handled, especially when reading from sources other than direct file paths.

```csharp
Wordize.Settings.SetLicense(MemoryStream(File.ReadAllBytes("Wordize.Net.lic")));
```

--------------------------------

### Convert Document From File to Stream

Source: https://docs.wordize.com/conversion

Converts a document from an input file directly to an output stream, specifying the desired SaveFormat.

```csharp
using var streamOut = File.Create("ConvertedDocument.1.Pdf");

Converter.Create()
    .From("DocumentIn.docx")
    .To(streamOut, SaveFormat.Pdf)
    .Execute();
```

--------------------------------

### Convert Document From File to File with SaveOptions

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, specifying advanced saving options via a SaveOptions instance. This example demonstrates PDF/UA-2 compliance.

```csharp
Converter.Create()
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf", new PdfSaveOptions() { Compliance = PdfCompliance.PdfUa2 })
    .Execute();
```

--------------------------------

### Convert Document From File to File with LoadOptions

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, specifying LoadOptions. This is useful for encrypted documents, providing the password during the load process.

```csharp
Converter.Create()
    .From("EncryptedDocument.docx", new LoadOptions() { Password = "1234" })
    .To("DocumentOut.pdf")
    .Execute();
```

--------------------------------

### Apply Wordize License from Embedded Resource

Source: https://docs.wordize.com/getting-started/licensing-and-subscription

This snippet illustrates applying a Wordize license that has been added as an embedded resource to the project. The SetLicense method is invoked with the short name of the resource file, simplifying license management within deployed applications.

```csharp
Wordize.Settings.SetLicense("YourResourceName.lic");
```

--------------------------------

### Convert Document From File to Multiple Output Types

Source: https://docs.wordize.com/conversion

Converts a single input document into multiple output file types simultaneously using multiple 'To' method calls.

```csharp
Converter.Create()
    .From("DocumentIn.pdf")
    .To("DocumentOut.xps")
    .To("DocumentOut.tiff")
    .To("DocumentOut.docx")
    .Execute();
```

--------------------------------

### Configure Font Settings with Wordize

Source: https://docs.wordize.com/conversion

This code snippet demonstrates how to configure global font settings for Wordize by specifying a folder containing fonts and indicating whether subfolders should be included. This helps minimize layout differences when fonts are substituted during conversion.

```csharp
Wordize.Settings.DefaultFontSettings.SetFontsFolder(@"C:\\Fonts", true);
```

--------------------------------

### Summarize Document to Images using AI

Source: https://docs.wordize.com/ai

This example shows how to summarize a document and render the output as an array of image streams. It allows for specifying the image format and requires API credentials for the AI model.

```csharp
AiModel model = OpenAiModel.Create("<api_url>", "<api_name>", "<api_key>");
Stream[] pages = Summarizer.SummarizeToImages("DocumentIn.docx", new ImageSaveOptions(SaveFormat.Png), model);
```

--------------------------------

### Check Grammar to Images using AI

Source: https://docs.wordize.com/ai

This example demonstrates checking grammar in a document and rendering the output as an array of image streams. It allows for specifying stylistic improvements and requires API credentials.

```csharp
AiModel model = OpenAiModel.Create("<api_url>", "<api_name>", "<api_key>");
Stream[] pages = GrammarChecker.CheckGrammarToImages("DocumentIn.docx", new ImageSaveOptions(SaveFormat.Png), model, new CheckGrammarOptions() { ImproveStylistics = true });
```

--------------------------------

### Convert Document to HTML using Standard API with SaveFormat

Source: https://docs.wordize.com/conversion

This code demonstrates converting a document to HTML format using the Standard API. It specifies the output format using the SaveFormat enumeration, providing more control over the conversion process.

```csharp
var doc = "Document.doc";

Converter.Convert(doc, "ConvertedDocument.2.html", SaveFormat.Html);
```

--------------------------------

### Convert Document From Stream to Stream

Source: https://docs.wordize.com/conversion

Converts a document from an input stream to an output stream, allowing for in-memory conversions or processing piped data. The SaveFormat is specified for the output.

```csharp
using var streamIn = File.OpenRead("Document1.docx");
using var streamOut = File.Create("ConvertedDocument.1.Pdf");

Converter.Create()
    .From(streamIn)
    .To(streamOut, SaveFormat.Pdf)
    .Execute();
```

--------------------------------

### Convert Document With FontSubstitution Warning Callback

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, configuring a ConverterContext to use a custom IWarningCallback. This example specifically handles font substitution warnings.

```csharp
ConverterContext context = new ConverterContext();
context.WarningCallback = new FontSubstitutionWarningCallback();

Converter.Create(context)
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf")
    .Execute();

private class FontSubstitutionWarningCallback : IWarningCallback
{
    public void Warning(WarningInfo info)
    {
        if (info.WarningType == WarningType.FontSubstitution)
            Console.WriteLine(info.Description);
    }
}
```

--------------------------------

### Convert Document With FontSettings Context

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, customizing font settings using a ConverterContext. This allows specifying custom font folders for document processing.

```csharp
ConverterContext context = new ConverterContext();
context.FontSettings = new FontSettings();
context.FontSettings.SetFontsFolder(@"C:\Fonts", true);

Converter.Create(context)
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf")
    .Execute();
```

--------------------------------

### Convert DOCX to PNG Image from Stream

Source: https://docs.wordize.com/conversion

Converts a DOCX document read from an input stream to PNG images. Each page of the document is saved as a separate image stream. The consumer is responsible for disposing of the output streams.

```csharp
using var streamIn = File.OpenRead("Document1.docx");

using (var outputStreams = Converter.Convert().From(streamIn).To(new ImageSaveOptions(SaveFormat.Png)).Execute())
{
    // Process outputStreams (each stream represents a page image)
}
```

--------------------------------

### Convert Document From File to List of Streams

Source: https://docs.wordize.com/conversion

Converts a document from a file into a list of streams, typically used for image conversion where each page becomes a separate stream. Supports multiple output types simultaneously.

```csharp
MemoryStream outStream = new MemoryStream();
List<Stream> outputStreams = new List<Stream>();

Converter.Create()
    .From("DocumentIn.docx")
    .To(outStream, SaveFormat.Odt)
    .To(outputStreams, SaveFormat.Png) // Note: a separate stream is created for each page. The streams disposing is the consumer responsibility.
    .Execute();
```

--------------------------------

### Build Report from Streams with JSON Data (C#)

Source: https://docs.wordize.com/developer-guide/linq-reporting

Illustrates building a report by loading the template from a stream and saving the output to another stream. This example uses JSON data loaded with specific options and saves the report to a file stream.

```csharp
// Load data from JSON with AlwaysGenerateRootObject load option enabled.
JsonDataLoadOptions jsonLoadOptions = new JsonDataLoadOptions();
jsonLoadOptions.AlwaysGenerateRootObject = true;
JsonDataSource ds = new JsonDataSource("Data.json", jsonLoadOptions);

ReportBuilderOptions reportBuilderOptions = new ReportBuilderOptions();
reportBuilderOptions.AllowMissingMembers = true;

// Build the report loading template from stream and saving the output to stream. 
using var streamIn = File.OpenRead("ReportingTemplate.docx");
using var streamOut = File.Create("ReportOption.7.docx");

// Note: The actual BuildReport call is missing in the provided text for this snippet.
```

--------------------------------

### Load Microsoft Office Fallback Settings

Source: https://docs.wordize.com/configuring-fonts

Loads predefined fallback settings that mimic the strategy used by Microsoft Word. This requires Microsoft Office fonts to be installed.

```csharp
Wordize.Settings.DefaultFontSettings.FallbackSettings.LoadMsOfficeFallbackSettings();
```

--------------------------------

### Convert DOCX to PNG Image from File Path

Source: https://docs.wordize.com/conversion

Converts a DOCX document specified by its file path to PNG images. Each page of the document is saved as a separate image stream. The consumer is responsible for disposing of the output streams.

```csharp
using (var outputStreams = Converter.Convert().From("Document1.docx").To(new ImageSaveOptions(SaveFormat.Png)).Execute())
{
    // Process outputStreams (each stream represents a page image)
}
```

--------------------------------

### Sign a Document with Digital Signature and Options (.NET)

Source: https://docs.wordize.com/signature

This example shows how to sign a document while specifying additional signing options such as comments, signing time, decryption password, signature provider ID, and XML-DSig level. It utilizes the SignOptions class in conjunction with CertificateHolder and the Signer.Sign method.

```csharp
SignOptions signOptions = new SignOptions();
signOptions.Comments = "My Signature";
signOptions.SignTime = DateTime.Now;
CertificateHolder holder = CertificateHolder.Create("morzal.pfx", "wordize");

Signer.Sign("Document.docx", "SignedDocument.3.docx", holder, signOptions);
```

--------------------------------

### Convert DOCX to PDF using C#

Source: https://docs.wordize.com/conversion

This snippet demonstrates how to convert a DOCX file to a PDF file using the Wordize Converter class. It requires the Wordize Core for .NET and Wordize Rendering for .NET modules. The conversion is performed using the Convert(string, string) method.

```csharp
var doc = "Document.docx";

Converter.Convert(doc, "ConvertedDocument.pdf");
```

--------------------------------

### Convert Document From File to File with SaveFormat

Source: https://docs.wordize.com/conversion

Converts a document from a file to another file, explicitly specifying the output SaveFormat. This can be done by passing the SaveFormat enum to the 'To' method.

```csharp
Converter.Create()
    .From("DocumentIn.docx")
    .To("DocumentOut.pdf", SaveFormat.Pdf)
    .Execute();
```

--------------------------------

### Convert DOCX to HTML using C#

Source: https://docs.wordize.com/conversion

This snippet shows how to convert a DOCX file to an HTML file using the Wordize Converter class. It requires the Wordize Core for .NET and Wordize Web for .NET modules. The conversion uses the Convert(string, string) method.

```csharp
var doc = "Document.docx";

Converter.Convert(doc, "ConvertedDocument.html");
```

--------------------------------

### Convert DOCX to PNG Images using C#

Source: https://docs.wordize.com/conversion

This snippet illustrates how to convert a DOCX document into PNG image files using the Wordize Converter class. It requires the Wordize Core for .NET and Wordize Rendering for .NET modules. The ConvertToImages method is used, which saves each page as a separate file when saving to a file.

```csharp
Stream[] pages = Converter.ConvertToImages("Document1.docx", new ImageSaveOptions(SaveFormat.Png));
```

--------------------------------

### Build Report with Object Array Data Sources (C#)

Source: https://docs.wordize.com/developer-guide/linq-reporting

Shows how to build a report using an array of objects as data sources with specified names. The example uses a Manager object and a string title, saving the report to 'ReportOption.5.docx'.

```csharp
// Use object as a data source.
Manager manager = new Manager() { Photo = "Photo.png", Name = "John Smith", Age = 37 };

object[] dataSources = new object[] { manager, "This is my title" };
string[] dataSourceNames = new string[] { "manager", "title" };

ReportBuilderOptions reportBuilderOptions = new ReportBuilderOptions();
reportBuilderOptions.AllowMissingMembers = true;

// Build report specifying array of data sources.
ReportBuilder.BuildReport("ReportingTemplate.docx", "ReportOption.5.docx", dataSources, dataSourceNames, reportBuilderOptions);
```

--------------------------------

### Compare Documents with Specific Save Format Using File Paths in C#

Source: https://docs.wordize.com/developer-guide/comparison

This example illustrates comparing two documents using their file paths and explicitly setting the save format for the output document. It configures CompareOptions, such as ignoring case changes, and then calls the Compare method with the specified SaveFormat.

```csharp
string firstDoc = "Document1.docx";
string secondDoc = "Document2.doc";

CompareOptions compareOptions = new CompareOptions();
compareOptions.IgnoreCaseChanges =true;

Comparer.Compare(firstDoc, secondDoc, "CompareDocuments.4.docx", SaveFormat.Docx, "Author", new DateTime(), compareOptions);
```

--------------------------------

### Replace Using Regular Expressions in Document (.NET)

Source: https://docs.wordize.com/developer-guide/replacement

These methods show how to perform search and replace operations using regular expressions. This is useful for matching dynamic text patterns. The examples cover different file and stream handling scenarios. Requires the Regex class and the Replacer module.

```.cs
string doc = "Document.docx";
Regex pattern = new Regex("gr(a|e)y");
string replacement = "lavender";

Replacer.Replace(doc, "Document.4.docx", pattern, replacement);
```

```.cs
string doc = "Document.doc";
Regex pattern = new Regex("gr(a|e)y");
string replacement = "lavender";

Replacer.Replace(doc, "Document.5.docx", SaveFormat.Docx, pattern, replacement);
```

```.cs
Regex pattern = new Regex("gr(a|e)y");
string replacement = "lavender";

using var streamIn = File.OpenRead("Document.docx");
using var streamOut = File.Create("Document.6.docx");

Replacer.Replace(streamIn, streamOut, SaveFormat.Docx, pattern, replacement);
```

--------------------------------

### Define Dummy Data Class

Source: https://docs.wordize.com/linq-reporting

A simple C# class definition for dummy data used in report building examples. It contains Name and Age properties.

```csharp
public class DummyData
{
    public string Name { get; set; }
    public string Age { get; set; }
}
```

--------------------------------

### Handle Font Substitution Warnings

Source: https://docs.wordize.com/configuring-fonts

Demonstrates how to implement the IWarningCallback interface to capture and log font substitution warning messages during document conversion. It shows how to create a converter context with a custom warning callback and execute the conversion.

```csharp
ConverterContext context = new ConverterContext();
context.WarningCallback = new FontSubstitutionWarningCallback();

Converter.Create(context)
    .From("C:\\Temp\\in.docx")
    .To("C:\\Temp\\out.pdf")
    .Execute();

private class FontSubstitutionWarningCallback : IWarningCallback
{
    public void Warning(WarningInfo info)
    {
        if (info.WarningType == WarningType.FontSubstitution)
            Console.WriteLine(info.Description);
    }
}
```

--------------------------------

### Build Report from Template using C#

Source: https://docs.wordize.com/developer-guide/linq-reporting

This snippet demonstrates how to build a report using a document template. It initializes data sources, specifies their names, and then uses the ReportBuilder to process input and output streams, saving the generated report in DOCX format. Dependencies include the System.IO namespace for file operations and a custom ReportBuilder class.

```csharp
Manager manager = new Manager() { Photo = "Photo.png", Name = "John Smith", Age = 37 };
            
object[] dataSources = new object[] { manager, "This is my title" };
string[] dataSourceNames = new string[] { "manager", "title" };

// Build the report loading template from stream and saving the output to stream. 
using var streamIn = File.OpenRead("ReportingTemplate.docx");
using var streamOut = File.Create("Report.9.docx");

ReportBuilder.BuildReport(streamIn, streamOut, SaveFormat.Docx, dataSources, dataSourceNames);
```

--------------------------------

### BuildReport with Stream Input/Output

Source: https://docs.wordize.com/linq-reporting

Builds a report by reading the template from an input stream and writing the output to an output stream.

```APIDOC
## POST /websites/wordize/BuildReport (Stream Input/Output)

### Description
This method allows for flexible report generation where both the input template and the output report are handled via streams. This is useful for in-memory operations or custom file handling.

### Method
POST

### Endpoint
/websites/wordize/BuildReport

### Parameters
#### Query Parameters
- **inputStream** (Stream) - Required - A stream containing the report template.
- **outputStream** (Stream) - Required - A stream to which the generated report will be written.
- **saveFormat** (SaveFormat) - Required - The format for the output report (e.g., Docx, Pdf).
- **dataSource** (object) - Required - The data source for the report (can be JSON, XML, or an object).
- **dataSourceName** (string) - Optional - The name of the data source, particularly useful for XML or specific object structures.
- **dataSources** (object[]) - Required (if `dataSource` is not used) - An array of objects to be used as data sources.
- **dataSourceNames** (string[]) - Required (if `dataSources` is used) - An array of names corresponding to each object in the `dataSources` array.

#### Request Body
No request body is used; all data and streams are handled via parameters.

### Request Example
```csharp
// Load data from JSON with AlwaysGenerateRootObject load option enabled.
JsonDataLoadOptions options = new JsonDataLoadOptions();
options.AlwaysGenerateRootObject = true;
JsonDataSource ds = new JsonDataSource("Data.json", options);

// Build the report loading template from stream and saving the output to stream. 
using var streamIn = File.OpenRead("ReportingTemplate.docx");
using var streamOut = File.Create("Report.7.docx");

ReportBuilder.BuildReport(streamIn, streamOut, SaveFormat.Docx, ds);
```

### Response
#### Success Response (200)
Indicates that the report was generated and written to the output stream successfully.

#### Response Example
(No specific response body example provided)
```

--------------------------------

### Merge Documents to Images using Streams

Source: https://docs.wordize.com/merge

This code example shows how to merge documents provided as streams and output the result as images. It allows specifying image save options and the merge format mode.

```csharp
using var firstStreamIn = File.OpenRead("Document1.pdf");
using var secondStreamIn = File.OpenRead("Document2.pdf");

Stream[] pages = Merger.MergeToImages(new Stream[] { firstStreamIn, secondStreamIn }, new ImageSaveOptions(SaveFormat.Png), MergeFormatMode.KeepSourceFormatting);
```

--------------------------------

### Sign Document with Stream Inputs and SignOptions

Source: https://docs.wordize.com/signature

This code snippet shows how to sign a document by reading from an input stream and writing to an output stream. It utilizes a CertificateHolder and SignOptions for the signing process.

```csharp
SignOptions signOptions = new SignOptions();
signOptions.Comments = "My Signature";
signOptions.SignTime = DateTime.Now;
CertificateHolder holder = CertificateHolder.Create("morzal.pfx", "wordize");

using var streamIn = File.OpenRead("Document.docx");
using var streamOut = File.Create("SignedDocument.4.docx");

Signer.Sign(streamIn, streamOut, holder);
```

--------------------------------

### Execute Mail Merge with TrimWhitespaces and DataTable (C#)

Source: https://docs.wordize.com/developer-guide/mail-merge

Performs a mail merge operation using the Execute method with a DataTable as the data source and the TrimWhitespaces option enabled. This example demonstrates merging multiple records from a DataTable.

```csharp
string doc = "MergeTemplate.docx;

DataTable dataTable = new DataTable();
dataTable.Columns.Add("FirstName");
dataTable.Columns.Add("Location");
dataTable.Columns.Add("Quantity");

DataRow dataRow = dataTable.Rows.Add(new string[] { "James Bond", "London", "7" });

MailMerger.Execute(doc, "MailMergeDataTable.3.docx", SaveFormat.Docx, new MailMergeOptions() { TrimWhitespaces = true }, dataTable);
```

--------------------------------

### Extract Page Ranges - .NET

Source: https://docs.wordize.com/splitting

Extracts a specific range of pages from a multi-page document. The 'ExtractPages' method takes the input document, output path, and the start and end page indices (0-based).

```.NET
var doc = "BigDocument.docx";

Splitter.ExtractPages(doc, "ExtractPages.1.docx", 0, 2);
```

--------------------------------

### Configure OpenAI Model Connection

Source: https://docs.wordize.com/ai

This code snippet illustrates connecting to an OpenAI model using Wordize AI for .NET. It involves specifying the model type, API key, and optionally organization and project details. Ensure your Wordize AI for .NET module is set up with correct OpenAI API credentials.

```csharp
AiModel model = OpenAiModel.Create(AiModelType.Gpt4OMini, "<your_api_key>").WithOrganization("<organization>").WithProject("<project>");
```

--------------------------------

### Add Image Watermark to Document (File Path Input)

Source: https://docs.wordize.com/watermark

Provides examples of using the SetImage method to embed an image watermark into a document, specifying input and output file paths. Supports different output formats.

```csharp
var doc = "Document.docx";
string watermarkImage = "Logo.jpg";

Watermarker.SetImage(doc, "WatermarkImage.1.docx", watermarkImage);
```

```csharp
var doc = "Document.docx";
string watermarkImage = "Logo.jpg";

Watermarker.SetImage(doc, "WatermarkImage.2.docx", SaveFormat.Docx, watermarkImage);
```

```csharp
var doc = "Document.docx";
string watermarkImage = "Logo.jpg";

ImageWatermarkOptions options = new ImageWatermarkOptions();
options.Scale = 50;

Watermarker.SetImage(doc, "WatermarkImage.3.docx", watermarkImage, options);
```

```csharp
var doc = "Document.docx";
string watermarkImage = "Logo.jpg";

ImageWatermarkOptions options = new ImageWatermarkOptions();
options.Scale = 50;

Watermarker.SetImage(doc, "WatermarkImage.4.docx", SaveFormat.Docx, watermarkImage, options);
```

--------------------------------

### BuildReport with Stream Input and JSON DataSource

Source: https://docs.wordize.com/linq-reporting

Builds a report by loading the template from a stream and saving the output to a stream, using a JSON data source.

```APIDOC
## POST /build/report/stream/json

### Description
Builds a report by loading the template from a stream and saving the output to a stream, using a JSON data source.

### Method
POST

### Endpoint
/build/report/stream/json

### Parameters
#### Request Body
- **templateStream** (stream) - Required - The input stream for the reporting template.
- **outputStream** (stream) - Required - The output stream for the generated report.
- **saveFormat** (string) - Required - The desired save format (e.g., "Docx", "Pdf").
- **dataSourcePath** (string) - Required - Path to the JSON data file.
- **jsonLoadOptions** (object) - Optional - Options for loading JSON data.
  - **alwaysGenerateRootObject** (boolean) - Optional - If true, ensures a root object is always generated.
- **reportBuilderOptions** (object) - Optional - Options for building the report.
  - **allowMissingMembers** (boolean) - Optional - If true, allows missing members during report generation.

### Request Example
(Note: Stream data is typically handled via multipart/form-data or base64 encoding in a JSON body)
```json
{
  "templateStream": "<base64_encoded_template_content>",
  "outputStream": "<base64_encoded_output_stream_placeholder>",
  "saveFormat": "Docx",
  "dataSourcePath": "Data.json",
  "jsonLoadOptions": {
    "alwaysGenerateRootObject": true
  },
  "reportBuilderOptions": {
    "allowMissingMembers": true
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating successful report generation.

#### Response Example
```json
{
  "message": "Report generated successfully to output stream."
}
```
```

--------------------------------

### BuildReport with Stream Input and XML DataSource

Source: https://docs.wordize.com/linq-reporting

Builds a report by loading the template from a stream and saving the output to a stream, using an XML data source.

```APIDOC
## POST /build/report/stream/xml

### Description
Builds a report by loading the template from a stream and saving the output to a stream, using an XML data source.

### Method
POST

### Endpoint
/build/report/stream/xml

### Parameters
#### Request Body
- **templateStream** (stream) - Required - The input stream for the reporting template.
- **outputStream** (stream) - Required - The output stream for the generated report.
- **saveFormat** (string) - Required - The desired save format (e.g., "Docx", "Pdf").
- **dataSourcePath** (string) - Required - Path to the XML data file.
- **dataSourceName** (string) - Optional - The name of the data source within the XML.
- **reportBuilderOptions** (object) - Optional - Options for building the report.
  - **allowMissingMembers** (boolean) - Optional - If true, allows missing members during report generation.

### Request Example
(Note: Stream data is typically handled via multipart/form-data or base64 encoding in a JSON body)
```json
{
  "templateStream": "<base64_encoded_template_content>",
  "outputStream": "<base64_encoded_output_stream_placeholder>",
  "saveFormat": "Docx",
  "dataSourcePath": "Data.xml",
  "dataSourceName": "manager",
  "reportBuilderOptions": {
    "allowMissingMembers": true
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating successful report generation.

#### Response Example
```json
{
  "message": "Report generated successfully to output stream."
}
```
```

--------------------------------

### Load Google Noto Font Fallback Settings

Source: https://docs.wordize.com/configuring-fonts

Loads predefined fallback settings specifically designed for use with Google Noto fonts. This enables a fallback strategy optimized for Noto.

```csharp
Wordize.Settings.DefaultFontSettings.FallbackSettings.LoadNotoFallbackSettings();
```

--------------------------------

### Enable Text Shaping for Specific Operation in Wordize

Source: https://docs.wordize.com/text-shaping

This example shows how to enable text shaping for a specific document conversion operation in Wordize. It involves creating a ConverterContext and setting the EnableTextShaping option before initiating the conversion. This allows for granular control over text shaping.

```.cs
ConverterContext converterContext = new ConverterContext();
converterContext.LayoutOptions.EnableTextShaping = true;

Converter.Create(converterContext)
    .From(inPath)
    .To(outPath)
    .Execute();
```

--------------------------------

### Sign Document with Digital Certificate (.NET)

Source: https://docs.wordize.com/developer-guide/signature

This snippet demonstrates signing a document using a digital certificate (.pfx file) and a password. It takes the input document path, output document path, and a CertificateHolder object as parameters. The CertificateHolder is created using the certificate file path and its password.

```csharp
CertificateHolder holder = CertificateHolder.Create("morzal.pfx", "wordize");

Signer.Sign("Document.docx", "SignedDocument.1.docx", holder);
```

```csharp
CertificateHolder holder = CertificateHolder.Create("morzal.pfx", "wordize");

using var streamIn = File.OpenRead("Document.docx");
using var streamOut = File.Create("SignedDocument.2.docx");

Signer.Sign(streamIn, streamOut, holder);
```

--------------------------------

### Compare Documents using Streams (Wordize for .NET)

Source: https://docs.wordize.com/developer-guide/comparison

Compares two documents provided as input streams and writes the comparison result to an output stream in the specified format. Requires Wordize Core and Wordize Comparison modules.

```csharp
using var firstStreamIn = File.OpenRead("Document1.docx");
using var secondStreamIn = File.OpenRead("Document2.docx");
using var streamOut = File.Create("CompareStreamDocuments.1.docx");

Comparer.Compare(firstStreamIn, secondStreamIn, streamOut, SaveFormat.Docx, "Author", new DateTime());
```

--------------------------------

### Extract Pages by Range

Source: https://docs.wordize.com/splitting

Extracts a specified range of pages from a document into a new document. This method requires the input document path, output document path, and the start and end page numbers (inclusive). It also supports stream-based operations.

```csharp
var doc = "BigDocument.docx";

Splitter.ExtractPages(doc, "ExtractPages.1.docx", 0, 2);
```

```csharp
var doc = "BigDocument.docx";

Splitter.ExtractPages(doc, "ExtractPages.2.docx", SaveFormat.Docx, 0, 2);
```

```csharp
using var streamIn = File.OpenRead("BigDocument.docx");
using var streamOut = File.Create("UnsignedDocument.docx");

Splitter.Split(streamIn, streamOut, SaveFormat.Docx, 0, 2);
```

--------------------------------

### Execute Mail Merge with TrimWhitespaces Option (C#)

Source: https://docs.wordize.com/developer-guide/mail-merge

Performs a mail merge operation using the Execute method, applying the TrimWhitespaces option to remove leading and trailing whitespace from merge field values. This example shows merging with string arrays for field names and values.

```csharp
string doc = "MergeTemplate.docx;

string[] fieldNames = new string[] { "FirstName", "Location", "Quantity" };
string[] fieldValues = new string[] { "James Bond", "London", "7" };

MailMergeOptions mailMergeOptions = new MailMergeOptions();
mailMergeOptions.TrimWhitespaces = true;

MailMerger.Execute(doc, "MailMerge.3.docx", SaveFormat.Docx, mailMergeOptions, fieldNames, fieldValues);
```

--------------------------------

### Compare Documents Using Streams with CompareOptions in C#

Source: https://docs.wordize.com/developer-guide/comparison

This code shows how to compare documents provided as streams, allowing for in-memory comparisons. It configures CompareOptions, including ignoring case sensitivity, and specifies the output save format before executing the comparison.

```csharp
using var firstStreamIn = File.OpenRead("Document1.docx");
using var secondStreamIn = File.OpenRead("Document2.docx");
using var streamOut = File.Create("CompareStreamDocuments.2.docx");

CompareOptions compareOptions = new CompareOptions();
compareOptions.IgnoreCaseChanges = true;

Comparer.Compare(firstStreamIn, secondStreamIn, streamOut, SaveFormat.Docx, "Author", new DateTime(), compareOptions);
```

--------------------------------

### Merge Documents with Custom Context (Keep Source Layout)

Source: https://docs.wordize.com/merge

Merges documents using a provided MergerContext to customize the merging behavior. This example specifically sets MergeFormatMode to KeepSourceLayout, preserving the original layout of each source document in the final output. It then saves the result to a DOCX file.

```csharp
MergerContext mergerContext = new MergerContext();
mergerContext.MergeFormatMode = MergeFormatMode.KeepSourceLayout;

Merger.Create(mergerContext)
    .From("DocumentIn.docx")
    .From("DocumentIn.pdf")
    .From("DocumentIn.doc")
    .From("DocumentIn.rtf")
    .To("DocumentOut.docx")
    .Execute();
```

--------------------------------

### POST /websites/wordize/BuildReport

Source: https://docs.wordize.com/linq-reporting

Builds a report by loading a template from a stream and saving the output to another stream. This method allows for data sources and custom report builder options.

```APIDOC
## POST /websites/wordize/BuildReport

### Description
Builds a report by loading a template from an input stream and saving the generated report to an output stream. Supports multiple data sources and advanced report building options.

### Method
POST

### Endpoint
/websites/wordize/BuildReport

### Parameters
#### Request Body
- **streamIn** (Stream) - Required - The input stream containing the report template.
- **streamOut** (Stream) - Required - The output stream to save the generated report.
- **saveFormat** (SaveFormat) - Required - The format to save the report in (e.g., Docx).
- **dataSources** (object[]) - Optional - An array of data objects to populate the report.
- **dataSourceNames** (string[]) - Optional - An array of names corresponding to the dataSources.
- **reportBuilderOptions** (ReportBuilderOptions) - Optional - Options to customize the report building process.

### Request Example
```json
{
  "streamIn": "<base64 encoded stream>",
  "streamOut": "<base64 encoded stream>",
  "saveFormat": "Docx",
  "dataSources": [{"manager": "John Doe", "title": "Sample Title"}],
  "dataSourceNames": ["manager", "title"],
  "reportBuilderOptions": {
    "allowMissingMembers": true
  }
}
```

### Response
#### Success Response (200)
Indicates the report was built successfully. The output is saved to the provided `streamOut`.

#### Response Example
```json
{
  "message": "Report built successfully."
}
```
```

--------------------------------

### Build Report from Stream with JSON Data and Options

Source: https://docs.wordize.com/developer-guide/reporting

This C# code snippet shows how to build a report by loading the template from a stream and saving the output to another stream, using JSON data and specific options. It configures JsonDataLoadOptions and ReportBuilderOptions, then opens file streams for reading the template and writing the report.

```csharp
// Load data from JSON with AlwaysGenerateRootObject load option enabled.
JsonDataLoadOptions jsonLoadOptions = new JsonDataLoadOptions();
jsonLoadOptions.AlwaysGenerateRootObject = true;
JsonDataSource ds = new JsonDataSource("Data.json", jsonLoadOptions);

ReportBuilderOptions reportBuilderOptions = new ReportBuilderOptions();
reportBuilderOptions.AllowMissingMembers = true;

// Build the report loading template from stream and saving the output to stream. 
using var streamIn = File.OpenRead("ReportingTemplate.docx");
using var streamOut = File.Create("ReportOption.7.docx");

ReportBuilder.BuildReport(streamIn, streamOut, SaveFormat.Docx, ds, reportBuilderOptions);
```

--------------------------------

### Customize Text Watermark with File Paths and Save Format (C#)

Source: https://docs.wordize.com/developer-guide/watermark

This example shows how to apply a text watermark to a document, specifying the output save format. It uses file paths for input and output and customizes the watermark color via TextWatermarkOptions. The output format is set to Docx.

```csharp
string doc = "Document.docx";
string watermarkText = "This is a watermark";

TextWatermarkOptions watermarkOptions = new TextWatermarkOptions();
watermarkOptions.Color = Color.Red;

Watermarker.SetText(doc, "WatermarkText.4.docx", SaveFormat.Docx, watermarkText, watermarkOptions);
```

--------------------------------

### Translate Document to File with AI

Source: https://docs.wordize.com/ai

Translates a document from an input file to an output file using a specified AI model and target language. Requires an AiModel instance and a valid file path. Supports various document formats.

```csharp
AiModel model = OpenAiModel.Create("<api_url>", "<api_name>", "<api_key>");
Translator.Translate("DocumentIn.docx", "DocumentOut.docx", model, Language.Ukrainian);
```

--------------------------------

### Perform Simple Mail Merge with .NET

Source: https://docs.wordize.com/mail-merge

This code example demonstrates how to perform a simple mail merge operation using a .docx template and an array of field names and values. It utilizes the MailMerger.Execute method to generate a personalized document. Ensure the 'MergeTemplate.docx' exists and the MailMerger class is accessible.

```.cs
var doc = "MergeTemplate.docx";

string[] fieldNames = new string[] { "FirstName", "Location", "Quantity" };
string[] fieldValues = new string[] { "James Bond", "London", "7" };

MailMerger.Execute(doc, "MailMerge.1.docx", fieldNames, fieldValues);
```

--------------------------------

### POST /websites/wordize/CreateReport

Source: https://docs.wordize.com/linq-reporting

Creates and executes a report using a fluent API. Allows specifying data sources, report options, input and output documents.

```APIDOC
## POST /websites/wordize/CreateReport

### Description
Builds and executes a report using a fluent API. This method allows for detailed customization of the report building process, including data sources and report options, and specifies input and output file paths.

### Method
POST

### Endpoint
/websites/wordize/CreateReport

### Parameters
#### Request Body
- **context** (ReportBuilderContext) - Required - Context object containing data sources and report builder options.
  - **dataSources** (object) - A dictionary where keys are data object instances and values are their corresponding names.
  - **reportBuilderOptions** (ReportBuilderOptions) - Optional - Options to customize the report building process.
    - **allowMissingMembers** (boolean) - Optional - If true, missing members are treated as null. Defaults to false.
    - **removeEmptyParagraphs** (boolean) - Optional - If true, empty paragraphs are removed. Defaults to false.
    - **inlineErrorMessages** (boolean) - Optional - If true, syntax error messages are inlined. Defaults to false.
    - **respectJpegExifOrientation** (boolean) - Optional - If true, JPEG images respect EXIF orientation. Defaults to false.
    - **updateFieldsSyntaxAware** (boolean) - Optional - If true, fields are updated after building, ignoring syntax within their results. Defaults to false.
    - **knownTypes** (Type[]) - Optional - A set of Type objects for use within report templates.
- **inputDocumentPath** (string) - Required - The path to the input document template.
- **outputDocumentPath** (string) - Required - The path where the generated report will be saved.

### Request Example
```json
{
  "context": {
    "dataSources": {
      "manager": {"Name": "John Smith", "Age": "37"}
    },
    "reportBuilderOptions": {
      "removeEmptyParagraphs": true
    }
  },
  "inputDocumentPath": "DocumentIn.docx",
  "outputDocumentPath": "DocumentOut.docx"
}
```

### Response
#### Success Response (200)
Indicates the report was created and executed successfully.

#### Response Example
```json
{
  "message": "Report created and executed successfully."
}
```
```

--------------------------------

### Replace Regex Using Streams

Source: https://docs.wordize.com/replacement

Replaces text matching a regular expression using input and output streams. This approach is suitable for stream-based processing and offers flexibility in handling document content. Includes options for fine-tuning the replacement.

```csharp
Regex pattern = new Regex("gr(a|e)y");
var replacement = "lavender";

using var streamIn = File.OpenRead("Document.doc");
using var streamOut = File.Create("Document.10.docx");

Replacer.Replace(streamIn, streamOut, SaveFormat.Docx, pattern, replacement, new FindReplaceOptions { FindWholeWordsOnly = true });
```

--------------------------------

### Build Report from JSON Data with Save Format (C#)

Source: https://docs.wordize.com/developer-guide/linq-reporting

This C# code snippet shows how to build a report from JSON data, explicitly specifying the output save format. It's similar to the previous example but includes the SaveFormat parameter for more control over the output file type.

```csharp
// Load data from JSON with AlwaysGenerateRootObject load option enabled.
JsonDataLoadOptions options = new JsonDataLoadOptions();
options.AlwaysGenerateRootObject = true;
JsonDataSource ds = new JsonDataSource("Data.json", options);

// Build the report explicitly specifying the output save format.
ReportBuilder.BuildReport("ReportingTemplate.docx", "Report.2.docx", SaveFormat.Docx, ds);
```

--------------------------------

### Specify Markdown Replacement Format (C#)

Source: https://docs.wordize.com/developer-guide/replacement

Illustrates setting the ReplacementFormat option to Markdown for search and replace, enabling the use of Markdown syntax in replacements.

```csharp
string doc = "Document.doc";
string pattern = "run";
string replacement = "**Text** *with* `formatting`";

FindReplaceOptions options = new FindReplaceOptions() { ReplacementFormat = ReplacementFormat.Markdown };

Replacer.Replace(doc, "Document.8.docx", SaveFormat.Docx, pattern, replacement, options);
```

--------------------------------

### Build Report from XML Data Source (C#)

Source: https://docs.wordize.com/developer-guide/linq-reporting

Builds a DOCX report using an XML file as the data source. It loads a template from a stream and saves the generated report to another stream. Requires the 'ReportingTemplate.docx' file.

```csharp
// Load data from XML
XmlDataSource ds = new XmlDataSource("Data.xml");

ReportBuilderOptions reportBuilderOptions = new ReportBuilderOptions();
reportBuilderOptions.AllowMissingMembers = true;

// Build the report loading template from stream and saving the output to stream. 
using var streamIn = File.OpenRead("ReportingTemplate.docx");
using var streamOut = File.Create("ReportOption.8.docx");

ReportBuilder.BuildReport(streamIn, streamOut, SaveFormat.Docx, ds, "manager", reportBuilderOptions);
```

--------------------------------

### Perform Mail Merge with Trim Whitespace Option

Source: https://docs.wordize.com/mail-merge

This code example demonstrates how to perform a mail merge operation while enabling the TrimWhitespaces option. This option ensures that leading and trailing whitespaces are removed from mail merge values, leading to cleaner output. It utilizes the Execute method with specified mail merge options.

```csharp
var doc = "MergeTemplate.docx;

string[] fieldNames = new string[] { "FirstName", "Location", "Quantity" };
string[] fieldValues = new string[] { "James Bond", "London", "7" };

MailMergeOptions mailMergeOptions = new MailMergeOptions();
mailMergeOptions.TrimWhitespaces = true;

MailMerger.Execute(doc, "MailMerge.3.docx", SaveFormat.Docx, mailMergeOptions, fieldNames, fieldValues);
```
Tokens:
Raw