Hur man använder eADM API-nycklar

Den här artikeln förklarar hur man använder en API-nyckeluppsättning för att ansluta till och göra anrop mot eADM API. Kodexemplen tillhandahålls i C# och PowerShell.

Förkunskapskrav

Innan du börjar ska du kontrollera att:

API-åtkomst är aktiverad för din organisation.
En API-nyckeluppsättning har skapats med nödvändiga behörigheter för de slutpunkter som du planerar att använda.

Grundläggande API

Bas-URI för alla API-anrop är: https://api.eadm.no/service.asmx

Du kan visa alla tillgängliga endpoints och deras nödvändiga parametrar genom att navigera till bas-URI:n i din webbläsare. Du kan också testa de flesta endpoints direkt från den här sidan.

Obs: Autentiseringstoken är giltiga i 8 timmar. Vi rekommenderar att tokenhämtningsprocessen paketeras i ett try-catch-block för att hantera utgångna tokens på ett elegant sätt.

Arbetsflöde för autentisering

Båda de följande exemplen visar samma tvåstegsprocess:

Ring till apilogin endpoint med API-användarnamn och lösenord för att hämta en autentiseringstoken.
Ring till getruleset med hjälp av token från föregående steg för att hämta en specifik regeluppsättning som ett JSON-objekt.

Exempel på kod

PowerShell-exempel

Det här skriptet autentiserar sig mot API:et, hämtar en token och använder sedan token för att hämta en specifik regeluppsättning.

KOD

PowerShell

KOD

$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

Exempel i C#

Denna C#-konsolapplikation demonstrerar samma arbetsflöde: autentisering för att få en token och sedan använda token för att hämta en regeluppsättning.

KOD

C#

KOD

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);
            }
        }
    }
}