Dynamic Document Property In Boomi: A Powerful Tool For Data Transformation

Let’s dive into the world of Dynamic Process Properties and Dynamic Document Properties in Boomi.

A Dynamic Process Property is a single, on-the-fly property you create within a Boomi process. It’s like a temporary variable that holds information specific to that process run. Think of it as a note you write to yourself while working on a specific task. Once the process is done, the note disappears.

A Dynamic Document Property is similar, but instead of being tied to the process itself, it’s attached to a specific document within that process. It’s like a label you stick on a specific item in a box. This label only applies to that item and not to the whole box. Dynamic document properties also have a limited lifespan and disappear after the document they’re associated with is processed.

In short:

Dynamic Process Properties are set for the entire process.
Dynamic Document Properties are set for each individual document.

This difference is crucial because Dynamic Process Properties can be accessed and used throughout the entire process, while Dynamic Document Properties are only available for the specific document they’re attached to.

Think of it this way: if you’re sending out a batch of emails, you might use a Dynamic Process Property to store the date and time of the send. This information applies to every email in the batch. Now, if you have a specific email with a personalized subject line, you might use a Dynamic Document Property to store that subject line.

The key takeaway is that Dynamic Document Properties don’t persist between branches in a process. This means if you have a document that goes through multiple branches, the Dynamic Document Property values won’t be passed from one branch to another. They exist solely within the branch they were set in.

Let me know if you’d like to explore other aspects of Boomi process properties!

You can set dynamic document properties in three main places:

Set properties shape
Set Document Property map function
Custom scripting

Let’s break down each of these options to help you understand how they work.

Set Properties Shape

The Set Properties Shape is a visual tool you can use directly within your workflow. Think of it like a little box that holds the settings for your document. Inside this box, you can define specific values for your document properties. It’s a great choice for quick and easy property modifications. For example, if you want to automatically add a document’s creation date as a property, you can easily do this with the Set Properties Shape.

Set Document Property Map Function

The Set Document Property Map function provides a more advanced approach to setting document properties. This function lets you manipulate properties based on data from other sources, like databases or spreadsheets. It’s a powerful tool for scenarios where you need to dynamically update properties with external data. For instance, if you have a database filled with customer information, you can use the Set Document Property Map function to automatically set properties like “Customer Name” and “Customer ID” for each document generated from that data.

Custom Scripting

For the ultimate control over your document properties, you can utilize custom scripting. This allows you to write your own code to manipulate properties in any way imaginable. If you’re familiar with programming, you can use scripting to create complex logic and even interact with external systems. It’s the most flexible option, but requires programming skills.

By understanding these three options, you’ll be equipped to set dynamic document properties with ease. Choose the method that best suits your needs and level of technical expertise.

Let’s dive into the world of document properties and understand the difference between document properties and dynamic document properties.

Document properties are like the basic information card attached to your document. They contain details about the document itself, such as its creation date, author, and file size. Think of them as the fundamental characteristics of your document. These properties are readily available and provide a concise overview of your document’s origins and key information.

Dynamic document properties, on the other hand, are more flexible and are often used for temporary storage. They are like sticky notes you can add to your document, allowing you to store extra information specific to your workflow. Dynamic document properties can be added and modified by the user and are particularly helpful in scenarios where you need to track certain information about a document for a specific purpose.

For example, you might use dynamic document properties to track the version number of a document, the date it was last reviewed, or the name of the reviewer. These properties can be defined and utilized by the process developer, allowing them to manage and track essential information related to the document during its lifecycle. Dynamic properties offer the flexibility to adapt to evolving needs within a workflow, making them invaluable for managing and organizing information within your documents.

Essentially, document properties provide a basic overview of the document, while dynamic document properties are more flexible, allowing you to add and modify information specific to your workflow.

Okay, let’s break down the advantages of using Dynamic Process Properties in Boomi.

Dynamic Process Properties are incredibly versatile in Boomi. They allow you to store values that can be used throughout your process, and even remembered across executions. This means you can use them to manage data, configuration settings, and even track the progress of your process.

Think of them like a “global variable” within your Boomi process. They can be used anywhere, except within an extension, and they’ll be available to all components within your process.

This means you don’t have to manually pass information between components or rely on external systems for data storage. You can simply store it in a dynamic process property and access it whenever you need it.

Let’s delve a bit deeper into the power of dynamic process properties:

Remembered across executions: A great benefit is that they are “sticky” – their values are persisted, meaning they’re saved across different executions of the same process on the same Atom. This means you can use them to track information about a particular process or user, even if the process is run multiple times.

For example, you could store a counter in a dynamic process property to keep track of how many times a process has run. Or, you could store a user’s ID to personalize the process flow for them.

Packed Component Power: Dynamic Process Properties are also a huge advantage when using packaged components. These components can be shared and reused across multiple processes, which makes your work more efficient. Dynamic Process Properties make sure the packaged component can remember its state and configuration, even when it’s used in different processes. Imagine creating a component that handles a specific API call and needs to store some credentials or settings. You can easily use a dynamic process property to store these details, ensuring your component is reusable and flexible.

Dynamic Process Properties can make your Boomi processes more efficient, flexible, and powerful. They offer a simple and consistent way to manage data and configurations throughout your processes, giving you more control and flexibility over your Boomi workflows.

Let’s break down the concept of dynamic documents with a great example: Wikipedia articles.

Wikipedia is a powerful platform where anyone can contribute to the ever-evolving pool of knowledge. Imagine a document that’s constantly being updated and improved by a global community. That’s what makes Wikipedia a dynamic document. Every time someone edits a page, those changes are immediately reflected for everyone viewing the article. It’s a living, breathing document that grows and adapts based on the collective effort of its contributors.

Think of it this way: Wikipedia is a dynamic document because it’s constantly in motion. New information is added, outdated information is corrected, and perspectives are constantly being refined. This dynamic nature makes Wikipedia a valuable resource, as it allows the knowledge base to stay up-to-date and relevant.

This is a key characteristic of dynamic documents – they are designed to change and adapt over time. They are not static files that remain unchanged.

Here’s a deeper dive into the concept of dynamic documents:

– Real-time Updates: Dynamic documents are designed to reflect the most current information. This is crucial in today’s fast-paced world where information is constantly evolving.
– User Collaboration: These documents often encourage user contributions. Imagine a document where individuals can add their insights, correct errors, or expand upon existing information. This collaborative aspect is key to making dynamic documents so powerful.
– Interactivity: Beyond simple updates, dynamic documents can be interactive. This could involve features like commenting sections, allowing users to engage with the document’s content. It fosters a sense of community and keeps the document alive and engaging.
– Dynamic Content Generation: Some dynamic documents go beyond simple editing. They can utilize technologies like scripting languages or databases to generate content based on specific parameters. This adds another layer of dynamism to the document.

Wikipedia is a shining example of a dynamic document because it embodies all of these characteristics. It’s a collaborative effort that’s constantly updated, interactive, and provides a dynamic platform for knowledge sharing.

A dynamic property system is a powerful tool that lets you add and manage new properties to objects while your application is running, without needing to change any code. This means you can define dynamic properties on objects and easily perform operations on them, making your application more flexible and adaptable.

Imagine you’re building a website where users can create profiles. You might want to let users add custom fields to their profiles, like their favorite hobbies or their preferred language. A dynamic property system allows you to do this without having to predefine all possible fields in your code. You can simply add new properties to user objects on the fly as needed.

Dynamic properties are particularly useful in situations where you need to handle data that is unpredictable or changes frequently. For example, you could use dynamic properties to store information about user preferences, track changes to data over time, or manage complex relationships between different objects.

Here are some key benefits of using a dynamic property system:

Flexibility: You can easily add and remove properties without modifying code.
Extensibility: Your application can handle new types of data without needing to be rebuilt.
Efficiency: You can work with complex data structures without writing a lot of code.

Overall, dynamic property systems provide a flexible and powerful way to manage data in your applications, making your code more maintainable and your applications more adaptable to changing requirements.

Boomi has two types of properties: Dynamic and Process.

Let’s break down the difference between these two properties.

Dynamic Properties are properties that are set at runtime, based on the data that is flowing through your Boomi process. This means that the value of a dynamic property can change depending on the specific data that is being processed. For example, you might use a dynamic property to store the name of a file that is being processed, or the date and time that a process was started.

Process Properties are properties that are defined at design time, and their values remain constant throughout the execution of a process. This means that the value of a process property is set when you create a process and does not change during the execution of that process. For example, you might use a process property to store the name of a database connection, or the path to a file that you need to access.

Dynamic properties offer flexibility and adaptability by allowing you to dynamically modify a process’s behavior based on the data being processed. On the other hand, process properties provide consistency and predictability by ensuring that certain values remain fixed throughout the execution of a process.

By understanding the difference between these two types of properties, you can effectively leverage them to build robust and flexible Boomi processes that meet your specific needs.

Microsoft 365 documents come with a few standard properties that help you organize and identify them. These properties include author, title, and subject. You can customize these properties by adding your own text values. For example, you could use the title property to add a descriptive name to your document. This could be especially helpful if you have multiple versions of the same document or if you’re working on a document with a team.

You can add even more information to your documents by using custom properties. Custom properties are like extra labels that you can use to organize and categorize your files. You can create custom properties for almost any kind of information, such as keywords, project names, or even due dates.

Here are some examples of how you might use custom properties:

Keywords: You might add keywords like “marketing” or “sales” to a document to help you find it later.
Project Names: You could use custom properties to assign documents to specific projects.
Due Dates: You might use custom properties to add due dates to documents that are part of a project or assignment.

Custom properties can really help you manage your documents, and the best part is that you can create as many as you need.

Dynamic document properties don’t persist between branches. A document property set on one branch won’t be available on another branch. However, if you set the property before branching, it will be accessible on each subsequent branch. This is because document properties are attached to a document and follow that document down its specific path until completion.

Think of it like this: Imagine you have a physical document, like a research paper. You can add notes and comments to the paper itself, but those notes won’t magically appear on copies of the paper you give to other people. The notes stay with the original document. Similarly, with dynamic document properties, the property is part of the document’s history and is inherited by all branches that descend from the point where the property was initially set.

However, if you create a new branch later on, the original document’s notes won’t be there. Think of this new branch as a new copy of the research paper, but without the original notes. In the same way, any dynamic document property set after the branch point won’t be available on the new branch.

So, if you need to use the same document property across different branches, you’ll want to set it before creating any branches. This will ensure that the property is available for all branches, including future ones.

Let’s break down the idea of a dynamic document property. As the name implies, it’s a property attached to a document that can change as it moves through different stages in a process.

Think about it this way: imagine you have a bunch of invoices, like, say, 1000 of them. Now, let’s say you’ve created a dynamic document property called Unique Transaction ID. Each of those 1000 invoices would have its own, unique Unique Transaction ID property value. So, if you had 1000 invoices, you would also have 1000 unique instances of the Unique Transaction ID property, each with a different value.

Dynamic document properties can be really useful when you need to track information about a document as it goes through different steps. For instance, you could use a dynamic document property to store the date a document was created, the name of the person who created it, or the status of the document. This can help you to easily keep track of where things are at and identify any bottlenecks or issues that might arise.

Let’s take a closer look at how dynamic document properties can benefit you:

– Automation and efficiency:Dynamic document properties can help you to automate tasks and processes. For example, you could use a dynamic document property to automatically route a document to the right person based on its content or status.

– Improved data management:Dynamic document properties can help you to manage data more effectively. For instance, you could use a dynamic document property to store information about a document in a central location, making it easier to access and analyze.

– Enhanced visibility:Dynamic document properties can help you to gain better visibility into your documents. You can use them to track the progress of documents, identify bottlenecks, and make sure that documents are being handled correctly.

– Streamlined workflows:Dynamic document properties can help you to streamline your workflows by making it easier to track the movement of documents and to automate tasks.

By utilizing dynamic document properties, you can gain a powerful tool for simplifying document management and improving the overall efficiency of your processes.

In Boomi, you can set property values in several ways. The most common method is using the set properties shape. This shape allows you to easily set the value of a property within your process. Another way is to use the map function. This function lets you define a mapping between a source value and a property value. Finally, you can also use custom scripting to set and get property values. To learn more about the com.boomi.execution.ExecutionUtil class and its methods for working with properties, you can consult the Boomi documentation.

Diving Deeper into Property Values

Let’s break down the ways to set property values in Boomi:

1. The Set Properties Shape:

* This shape is your go-to for straightforward property value assignment. You simply drag and drop it into your process, and then configure the shape to define which property you want to modify and the new value you want to assign.
* Think of it like this: You have a box labeled “Property Name,” and you’re putting a specific “Value” into that box. The “Set Properties” shape does this for you within your Boomi process.

2. The Map Function:

* For more complex scenarios where you need to dynamically determine property values based on other data, the map function is your friend.
* You can create mappings within the map function to connect source values from one location (like a data field) to the property you want to set.
* Imagine you have a spreadsheet: One column has “Customer Names,” and another column has “Customer IDs.” Using the map function, you could link “Customer Name” to the “Customer ID” property, ensuring the right ID gets assigned whenever you use that property.

3. Custom Scripting:

* This method is for when you need a lot of flexibility and control.
* With custom scripting, you write code using Java or Groovy to manipulate property values directly.
* It’s like having a custom tool: You can perform complex logic to set property values based on conditions or specific calculations.

Remember, using custom scripting requires a bit more technical knowledge, so it’s best suited for advanced users.

Let’s talk about dynamic document properties (DDP). Think of them as temporary labels you can attach to individual documents. Unlike other properties that are connected to the whole system, these labels are specific to each document and move with it throughout the process.

You can name these labels anything you want, and they act like little tags that follow the document everywhere it goes. This is especially helpful when you’re working with batches of documents. Imagine you have a bunch of documents flowing through a system, and you want to do something specific to each one. DDPs let you give each document its own unique instruction. For example, if you’re processing invoices, you might use a DDP to indicate whether each invoice needs to be reviewed by a manager or not.

Here’s how it works: You set and retrieve these properties for each document as it passes through specific points in the process, such as a “set properties” or “map” shape. This gives you a flexible way to manage and track data for each document individually.

Think of DDPs like this: Imagine you have a box of different toys. You want to organize them, so you use labels like “cars,” “puzzles,” and “dolls.” Each toy gets a label based on what it is. These labels help you find the toys you need quickly. DDPs work in a similar way, they help you identify and organize documents based on their specific needs.

Here are some real-world examples of DDPs:

* You can use DDPs to track the status of a document, like “Pending approval,” “Approved,” or “Rejected.”
* If you’re processing insurance claims, you could use a DDP to indicate the type of claim, like “Medical,” “Dental,” or “Auto.”
* When you’re working with marketing campaigns, you might use DDPs to store information like the source of a lead or the campaign it’s associated with.

Keep in mind that these labels are temporary, so they don’t stay with the document forever. They exist only during the processing cycle. Once the document is processed, the labels disappear.

By using DDPs, you can make your document processing more efficient and customizable. It’s like having a little extra information attached to each document, helping you make informed decisions along the way.

Dynamic document properties – Boomi

Dynamic document properties are properties that the process developer can define and use to temporarily store additional pieces of information about a given document. They boomi.com

Dynamic document property use cases – Boomi

To perform very complex validation or routing logic, you can configure a dynamic map function instead of a Decision, Route, Connector, and other steps. The steps in the boomi.com

How to Get and Set All Properties Using Groovy – Boomi

Using groovy to get and set the dynamic document properties. //libraries needed. import java.util.Properties; import java.io.InputStream; for (int i = 0; i < boomi.com

Article: Property Types and Behavior – Boomi Community

Dynamic document property. Dynamic document properties (DDP) are temporary properties tied to a document (as opposed to being tied to the connector). It boomi.com

What are the differences between a dynamic doc property and a

A Dynamic Process Property is a single, “on-the-fly” property that you create. In other words, A Process Property will be set for the process, whereas a Dynamic Document boomi.com

Document properties – Boomi

There are two types of document properties: Standard document properties (called simply document properties) — Contain run-time specific information such as connector or boomi.com

Dell Boomi Online Training Day 17 Properties (Document,

BB Tech #Dellboomionlinetraining #Document Properties #Dynamicdocumentproperties#Processproperties#DynamicProcesspropertiesComplete YouTube

Boomi Training Lecture #30 Associate developer – Dynamic

the credit of This video goes to Dell Boomi Training & Certification section.if you want to know more about dell Boomi Traning, please visit this site https… YouTube

boomi – Document versus Dynamic Document Property – Stack

There are two types of document properties: standard document properties:contain run-time specific information such as connector or trading partner Stack Overflow

XSLT Transformation step: working with dynamic document

You can use dynamic document properties with the XSLT Transformation step to set default values, to drive conditional transformations, or to output specific values from the boomi.com