Arbeidstilsynet.Common.AltinnApp 2.6.0

Introduction

A collection of common patterns and extensions for cross-cutting concerns in Altinn applications.

📖 Installation

To install the package, you can use the following command in your terminal:

dotnet add package Arbeidstilsynet.Common.AltinnApp

🚀 Features

• Extension Methods for common Altinn operations
• Abstract Data Processors for handling data changes
• Country Code Lookup with country dialing codes and names
• Altinn Options Provider for country dropdowns
• Embedded Resource Utilities for JSON data

🧑‍💻 Usage

Dependency Injection Setup

Altinn Application Utilities

Add services to your service collection:

public void ConfigureServices(IServiceCollection services)
{
    // Add country code lookup functionality
    services.AddLandskoder();
    
    // OR add country options for Altinn dropdowns (includes AddLandskoder)
    services.AddLandOptions();

}

Structured Data

1. Add the structured data extension to your service collection, specifying the data model and structured data types

    // Adds a DataElement to you instance to hold structured data of type TStructuredData
    // Content type will be "application/json".
    services.AddStructuredData<TDataModel, TStructuredData>((datamodel) =>
    {
        return new TStructuredData
        {
            // Property mappings here
        };
    });

2. Add the data element to your App/config/applicationmetadata.json dataTypes

{
  "dataTypes": [
    {
      "id": "structured-data",
      "allowedContentTypes": [
        "application/json"
      ],
      "allowedContributors": [
        "app:owned"
      ]
    },
    /// ...Other data types
  ]
}

Extension Methods

Instance Extensions

Easily extract common information from Altinn instances:

using Arbeidstilsynet.Common.AltinnApp.Extensions;

public class MyService
{
    public void ProcessInstance(Instance instance)
    {
        // Extract instance GUID
        Guid instanceId = instance.GetInstanceGuid();
        
        // Get application name
        string appName = instance.GetAppName();
        
        // Get party ID of instance owner
        int partyId = instance.GetInstanceOwnerPartyId();
        
        Console.WriteLine($"Processing {appName} instance {instanceId} for party {partyId}");
    }
}

DataClient Extensions

Simplified data operations with Altinn instances:

using Arbeidstilsynet.Common.AltinnApp.Extensions;

public class DataService
{
    private readonly IDataClient _dataClient;
    
    public DataService(IDataClient dataClient)
    {
        _dataClient = dataClient;
    }
    
    public async Task<MyDataModel?> GetFormData(Instance instance)
    {
        // Get form data with default data type "structured-data"
        return await _dataClient.GetSkjemaData<MyDataModel>(instance);
        
        // Or specify custom data type
        return await _dataClient.GetSkjemaData<MyDataModel>(instance, "customDataType");
    }
    
    public async Task CleanupAttachments(Instance instance, List<DataElement> unusedAttachments)
    {
        foreach (var attachment in unusedAttachments)
        {
            // Delete data element and remove from instance
            await _dataClient.DeleteElement(instance, attachment, delay: true);
        }
    }
}

Assembly Extensions

Load and deserialize embedded JSON resources:

using Arbeidstilsynet.Common.AltinnApp.Extensions;

public class ConfigurationService
{
    public Task<MyResourceType> GetResource()
    {
        var assembly = Assembly.GetExecutingAssembly();
        
        // Load embedded JSON resource and deserialize
        return assembly.GetEmbeddedResource<MyResourceType>("resource.json");
    }
}

Country Code Lookup

Use the built-in country code lookup service:

public class AddressService
{
    private readonly ILandskodeLookup _landskodeLookup;
    
    public AddressService(ILandskodeLookup landskodeLookup)
    {
        _landskodeLookup = landskodeLookup;
    }
    
    public async Task<string> GetCountryInfo(string countryCode)
    {
        // Look up specific country by ISO code
        var country = await _landskodeLookup.GetLandskode("NOR");
        if (country != null)
        {
            return $"{country.Land} ({country.Kode})"; // "Norway (+47)"
        }
        
        return "Unknown country";
    }
}

Abstract Data Processors

Create data processors that respond to form data changes:

Simple Data Processor

using Arbeidstilsynet.Common.AltinnApp.Abstract.Processing;

public class MyFormDataProcessor : BaseDataProcessor<MyDataModel>
{
    private readonly ILogger<MyFormDataProcessor> _logger;
    
    public MyFormDataProcessor(ILogger<MyFormDataProcessor> logger)
    {
        _logger = logger;
    }
    
    protected override async Task ProcessData(MyDataModel current, MyDataModel? previous)
    {
        if (previous == null)
        {
            _logger.LogInformation("New form data created");
            return;
        }
        
        _logger.LogInformation("Form data updated");
        
        // Your custom processing logic here
    }
}

Member-Specific Processor

public class EmailChangeProcessor : MemberProcessor<MyDataModel, string>
{    
    protected override string? AccessMember(MyDataModel dataModel)
    {
        return dataModel.Email;
    }
    
    protected override async Task ProcessMember(
        string? currentEmail, 
        string? previousEmail, 
        MyDataModel currentDataModel, 
        MyDataModel previousDataModel)
    {
        // Your custom logic to handle the changed member
    }
}

List Processor

public class AttachmentListProcessor : ListProcessor<MyDataModel, AttachmentInfo>
{
    protected override List<AttachmentInfo>? AccessMember(MyDataModel dataModel)
    {
        return dataModel.Attachments; // Point to the list we want to process
    }
    
    protected override async Task ProcessListChange(
        List<AttachmentInfo>? currentList, 
        List<AttachmentInfo>? previousList, 
        MyDataModel currentDataModel, 
        MyDataModel previousDataModel)
    {
        // Process that attachments have been removed or added
    }
    
    protected override async Task ProcessItem(
        AttachmentInfo currentItem, 
        AttachmentInfo previousItem, 
        MyDataModel currentDataModel, 
        MyDataModel previousDataModel)
    {
        // Process individual item changes
    }
}

Registration of Data Processors

Register your data processors in dependency injection:

public void ConfigureServices(IServiceCollection services)
{
    // Register data processors
    services.AddTransient<IDataProcessor, MyFormDataProcessor>();
    services.AddTransient<IDataProcessor, EmailChangeProcessor>();
    services.AddTransient<IDataProcessor, AttachmentListProcessor>();
}