Comment utiliser les clés API eADM | Base de connaissances Identum

Cet article explique comment utiliser un jeu de clés API pour se connecter à l'API eADM et effectuer des appels vers celle-ci. Les exemples de code sont fournis en C# et en PowerShell.

Conditions préalables

Avant de commencer, assurez-vous que :

L'accès à l'API est activé pour votre organisation.
Un ensemble de clés API a été créé avec les autorisations nécessaires pour les points de terminaison que vous prévoyez d'utiliser.

Principes fondamentaux des API

L'URI de base pour tous les appels API est : https://api.eadm.no/service.asmx

Vous pouvez consulter tous les points de terminaison disponibles ainsi que les paramètres requis en accédant à l'URI de base dans votre navigateur. Vous pouvez également tester la plupart des points de terminaison directement depuis cette page.

Remarque : les jetons d'authentification sont valables pendant 8 heures. Nous vous recommandons d'encadrer le processus de récupération du jeton dans un bloc try-catch afin de gérer correctement les jetons expirés.

Processus d'authentification

Les deux exemples suivants illustrent le même processus en deux étapes :

Appelez le apilogin point de terminaison en indiquant le nom d'utilisateur et le mot de passe de l'API afin d'obtenir un jeton d'authentification.
Appelez le getruleset point de terminaison en utilisant le jeton obtenu à l'étape précédente pour récupérer un ensemble de règles spécifique sous forme d'objet JSON.

Exemples de code

Exemple PowerShell

Ce script s'authentifie auprès de l'API, récupère un jeton, puis utilise ce jeton pour récupérer un ensemble de règles spécifique.

PowerShell

$baseUrl = "https://api.eadm.no/service.asmx"
$username = "apiapi" # Your API username
$password = Read-Host -Prompt "Enter a password"
$orgnr = "NOXXXXXXXXX" # Your organization number

# 1. Authenticate and get a token
$loginUrl = "$($baseURL)/apilogin"
$loginBody = @{
    orgnr    = $orgnr
    username = $username
    password = $password
}
$loginResponse = Invoke-RestMethod -Method 'Post' -Uri $loginUrl -Body $loginBody

$token = $null
if ($loginResponse.data[0]) {
    $token = $loginResponse.data[0]
}
else {
    Write-Host "Login failed. Check the audit log for ID: $($loginResponse.lasterror)"
    return
}

# 2. Fetch a ruleset using the token
$rulesetUrl = "$($baseURL)/getruleset"
$rulesetBody = @{
    token = $token
    id    = "36477" # The ID of the ruleset to fetch
    orgnr = $orgnr
}
$rulesetResponse = Invoke-RestMethod -Method 'Post' -Uri $rulesetUrl -Body $rulesetBody

$objects = $rulesetResponse.data
# Process the $objects variable which now contains the ruleset data

Exemple en C#

Cette application console C# illustre le même processus : s'authentifier pour obtenir un jeton, puis utiliser ce jeton pour récupérer un ensemble de règles.

C#

using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;

// DataContract for deserializing the JSON response
[DataContract]
public class JData
{
    [DataMember]
    public string lasterror { get; set; }

    [DataMember]
    public Object[] data { get; set; }
    
    // Other potential response fields
    public string queryid { get; set; }
    public DateTime exportstart { get; set; }
    public DateTime exportend { get; set; }
    public int initatedby { get; set; }
    public string returncode { get; set; }
    public int pagenx { get; set; }
    public int resultsprpage { get; set; }
    public int pages { get; set; }
    public int totalresults { get; set; }
    public string[] sortablecolumns { get; set; }
    public string sortedby { get; set; }
    public bool sortascending { get; set; }
    public string[] searchablecolumns { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        string orgNr = "NOXXXXXXXXX"; // Your organization number
        string userName = "api-user"; // Your API username
        string password = "your-password"; // Your API password
        string apiUrl = "https://api.eadm.no/service.asmx";
        int ruleSetIdToFetch = 40718;

        try
        {
            string authToken = GetAuthToken(orgNr, userName, password, apiUrl);
            if (!string.IsNullOrEmpty(authToken))
            {
                Console.WriteLine("Authentication successful.");
                GetRuleSet(authToken, orgNr, ruleSetIdToFetch, apiUrl);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }

    // Generic method to deserialize JSON
    public static T JsonDeserialize<T>(string jsonString)
    {
        var ser = new DataContractJsonSerializer(typeof(T));
        var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
        T obj = (T)ser.ReadObject(ms);
        return obj;
    }

    // Method to get the authentication token
    private static string GetAuthToken(string orgNr, string userName, string password, string apiUrl)
    {
        using (var client = new WebClient())
        {
            var values = new NameValueCollection();
            values["orgnr"] = orgNr;
            values["username"] = userName;
            values["password"] = password;

            var response = client.UploadValues(apiUrl + @"/apilogin", values);
            var responseString = Encoding.Default.GetString(response);
            JData jresp = JsonDeserialize<JData>(responseString);

            if (string.IsNullOrEmpty(jresp.lasterror))
            {
                return jresp.data[0].ToString();
            }
            else
            {
                throw new Exception("Authentication failed: " + jresp.lasterror);
            }
        }
    }

    // Method to get a specific ruleset
    public static void GetRuleSet(string token, string orgNr, int ruleSetId, string apiUrl)
    {
        using (var client = new WebClient())
        {
            var values = new NameValueCollection();
            values["token"] = token;
            values["orgnr"] = orgNr.ToUpper();
            values["id"] = ruleSetId.ToString();

            var response = client.UploadValues(apiUrl + @"/getruleset", values);
            var responseString = Encoding.Default.GetString(response);
            JData jresp = JsonDeserialize<JData>(responseString);

            if (!string.IsNullOrEmpty(jresp.lasterror))
            {
                throw new Exception("Failed to get ruleset: " + jresp.lasterror);
            }
            else
            {
                Console.WriteLine("Result OK");
                Console.WriteLine(responseString);
            }
        }
    }
}

Dernière mise à jour : 29 août 2025