The Digizuite DAM comes with a toolbox of functionality that allows you standardize the integration process following certain patterns. Do you need 100% control and access to all functionality then you can choose our great open API or our SDK that is documented further down. Before going down that route it might be well worth investigating the standard toolbox that Digizuite already provides
Patterns that are very common in the Enterprise Ecosystem would be
Broadcast or one-way Data Exchange
A form of integration where (based on some business logic within DAM), data is send to a receiving system. It be very specific business logic that triggers it such as certain metadata fields changing and has a certain value, or it can be all creates, modifications and deletes of assets that must flow to the receiving end.Bi-direction Data Exchange
It is a combination of the above, but where either certain must be broadcasted but then based on the response something updated in the broadcasting end (Digizuite). Here it could more complicated where certain changes in the receiving system must trigger updates in the Digizuite platform.Correlation Data Exchange
Data from the integrated systems must be correlated in certain ways. An example could be a PIM platform that must not only receive assets but those assets must automatically be linked to a product based on the Product ID on a metadata field on the asset in Digizuite.Enhanced UI with an Asset Picker
An integration pattern that does not as such move data around is enhancing a 3rd party UI with more capability coming from another system. An asset picker from Digizuite which is being popped on a certain action. When an asset is selected or clicked in the asset picker then at that time it must be integrated into the 3rd party platform (could be adding the assets into a media library, or adding it to an email template for adding it for your product in a PIM as done with our InRiver connector)Combined Data Exchange and UI
This one combines both data exchange (where assets are moved back and forth) with having UI capability in the 3d party platform as described above. Essentially, you have flow of data that is then further complimented with a UI that allows you handle assets in Digizuite right there when needed. An example is making a crop that is then automatically flowing from Digizuite to the receiving system. It could be updating metadata such as assigning a product ID without leaving your host platform which will then trigger the integration in real time.
Automation Flows
Digizuite has a very powerful automation engine which allows customers to construct business logic in a drag & drop fashion. The logic consists of a number of steps that can either be a trigger, an action, a filter or for-loop (iterating elements). So an automation could be triggered based on metadata changes on an asset, or an asset arriving at a certain state in a workflow, and then the steps can filter if that change is relevant and if it is then perform certain actions within the DAM or externally. Full docs are here: DC 5.6 Automations.
In this context, it is the ‘externally' part that is interesting to integration. An automation has an action which can invoke an external endpoint with values from the current automation (could be an asset ID or workflow ID) as query parameters. The external system could be simply utilizing a 3rd party service but it could also be a data integration where a downstream system must be notified (broadcast).
Many 3rd party platforms have APIs which could be triggered directly with these invoke endpoints but in many cases you would need to extend the integration with more. The Digizuite Automation could handle all business logic to narrow down what should be triggering the Integration but then the Invoke Endpoint could call a service that simply takes care of transporting what is received to the downstream platform.
One way to extend the Automation is by using own services or maybe creating small purpose-built Azure Functions. For a simple teams or slack integration, or if you wish to extend the platform to talk to your favorite Task & Project Management Software then simply add that API logic in an an Azure Function with 4-5 lines of code and let it be invoked from automation as described above.
Integration Endpoints
Standardizing the Integration Process with Patterns
Extensions with Azure Functions (or own Service)
Azure Functions
[FunctionName("TriggerTeamsIntegration")]
[OpenApiOperation(operationId: "TeamsIntegration", tags: new[] { "Teams", "Integration" })]
[OpenApiSecurity("function_key", SecuritySchemeType.ApiKey, Name = "code", In = OpenApiSecurityLocationType.Query)]
[OpenApiParameter(name: "title", In = ParameterLocation.Query, Required = true, Type = typeof(string), Description = "The **Title** parameter")]
[OpenApiParameter(name: "text ", In = ParameterLocation.Query, Required = false, Type = typeof(string), Description = "The **Text ** parameter")]
[OpenApiParameter(name: "color", In = ParameterLocation.Query, Required = true, Type = typeof(string), Description = "The **Color** parameter")]
[OpenApiParameter(name: "assetId", In = ParameterLocation.Query, Required = true, Type = typeof(string), Description = "The **Color** parameter")]
[OpenApiResponseWithBody(statusCode: HttpStatusCode.OK, contentType: "text/plain", bodyType: typeof(string), Description = "The OK response")]
public async Task<IActionResult> RunTeams(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req)
{
_logger.LogInformation("C# HTTP trigger function processed a request.");
string title = req.Query["title"];
string text = req.Query["text"];
string color = req.Query["color"];
string assetId = req.Query["assetId"];
var assetUrl = $"https://demo-dam-dam-dam.my-domain.com/asset/{assetId}/asset";
if (string.IsNullOrEmpty(title) || string.IsNullOrEmpty(text) || string.IsNullOrEmpty(color))
{
return new BadRequestErrorMessageResult("Invalid Query parameters. Title, text and color are all mandatory");
}
// Adding get asset name to title
var asset = await GetAssetById(assetId);
if (asset != null)
{
title += $" ({asset.Name})";
}
// Let us try it out!
var url = "<INSERT WEBHOOK URL HERE>";
var client = new TeamsNotificationClient(url);
var message = new MessageCard();
message.Title = title;
message.Text = text;
message.Color = color;
message.Sections = new List<MessageSection>();
message.PotentialActions = new List<PotentialAction>();
message.PotentialActions.Add(new PotentialAction()
{
Name = "Open Asset in Media Manager",
Targets = new List<PotentialActionLink>()
{
new()
{
Value = assetUrl
}
}
});
await client.PostMessage(message);
_logger.LogInformation($"Good to go {JsonConvert.SerializeObject(new { message })}");
return new OkObjectResult(message);
}
Using the SDK in the above context (using https://docs.microsoft.com/en-us/azure/azure-functions/functions-dotnet-dependency-injection to inject it)
.....
public async Task<Asset> GetAssetById(string assetId)
{
var parameters = new SearchParameters("GetAssets")
{
{"sAssetId", assetId}
};
var response = await _searchService.Search<Asset>(parameters);
var listOfAssets = response.Items.ToList();
return listOfAssets.Count > 0 ? listOfAssets.First() : null;
}
Adding the above to automation or an Integration Endpoint would be a simple exercise. Specifically for automation, one would go and add the following URL:
https://integration-functions.azurewebsites.net/api/TriggerTeamsIntegration?title=myTitle&text=myText&color=f0ad4e&assetId=123
To the Invoke Endpoint as made above then simply take the URL and add it here (remembering to add the right asset ID parameter):
