API-documentatie – Hoofdapp

Inleiding

API staat voor Application Programming Interface. Een API stelt u in staat om programmatisch te communiceren met bepaalde delen van RESPONSUM en informatie uit te wisselen. RESPONSUM biedt API-endpoints voor kernfunctionaliteiten/gegevens die nuttig kunnen zijn voor bepaalde automatiseringen en integraties met andere (operationele) systemen/tools.

Deze API-endpoints zullen in de loop van de tijd worden bijgewerkt/uitgebreid, maar we zullen ervoor zorgen dat ze achterwaarts compatibel blijven, zodat gemaakte integraties blijven werken. Als u vragen of verzoeken heeft voor nieuwe endpoints, laat het ons dan weten via support@responsum.eu.

Snel aan de slag

  1. Zorg ervoor dat API’s zijn ingeschakeld voor uw tenant. Deze zijn standaard uitgeschakeld, dus u moet mogelijk contact opnemen met support@responsum.eu.
  2. Zodra dit is ingeschakeld, kunt u naar instellingen > configuratie > mijn organisatie gaan; door te klikken op het hoogste niveau kunt u uw “tenant key” vinden in de eigenschappen
  3. Nu kunt u onze documentatie vinden onder instellingen > integraties > API-documentatie
  4. Maak een API-token aan door naar instellingen > integraties > API-tokens te gaan
  5. Er zijn enkele Node.JS JavaScript-codevoorbeelden hier beschikbaar: https://github.com/RESPONSUM-BE/RESPONSUM-api-example – U kunt de tenant key + de eerder gegenereerde API-token gebruiken om het uit te proberen.
  6. U kunt een diagram in ons Helpcenter vinden waarin de belangrijkste concepten in RESPONSUM worden uitgelegd. Dit zal u helpen onze basisstructuur te begrijpen, zodat u concepten gemakkelijk kunt terugvinden.
  7. Hier is een korte inleiding tot enkele belangrijke concepten – u kunt er hieronder meer diepgaand over lezen.
    1. UUID’s: U kunt uw eigen UUID’s maken of RESPONSUM-geformatteerde UUID’s genereren met behulp van https://api.responsum.app/v1/[tenant key]/uuids/[amount] – Als u uw eigen UUID’s genereert, zorg er dan absoluut voor dat ze 100% uniek zijn; er zijn bibliotheken beschikbaar als u ze nodig heeft, gebruik geen math.random 🙂
    2. Link-objecten: RESPONSUM maakt GEEN gebruik van typische op relaties gebaseerde modellering. Koppelingen tussen items zijn voor ons objecten.
    3. Versiebeheer: Vrijwel alle RESPONSUM-modellen zijn voorzien van versiebeheer. Dit betekent dat we wijzigingen voor alles bijhouden. Er zijn enkele specifieke API’s beschikbaar om hiermee om te gaan of om informatie op te vragen over de versiegeschiedenis & goedkeuring van een object
    4. Berekende velden: RESPONSUM berekent aan de serverzijde een aantal velden. Dat gebeurt automatisch. Bij het ophalen van een object geven we u ook onze berekende velden. U kunt deze niet handmatig bijwerken.
    5. Event-driven: Alles wat er in RESPONSUM gebeurt (aanmaken, bijwerken, verwijderen, versioneren, …) begint als een event. U kunt webhooks gebruiken om u te abonneren op allerlei soorten events. In wezen kan op alles wat er in RESPONSUM gebeurt, worden gereageerd met behulp van webhook-API’s.
  8. Het wordt altijd aanbevolen om de volledige handleiding te lezen voordat u aan de slag gaat. Het is een gevaarlijke wereld daarbuiten en u wilt uzelf niet bezeren – maar gewapend met deze snelstart hoop ik dat u het werkend krijgt. Veel succes!

Aan de slag

Controleren of de API is ingeschakeld voor uw tenant

Standaard is de RESPONSUM API uitgeschakeld op tenant-niveau en verborgen in onze UI.

Om de API voor uw tenant in te schakelen, moet u contact opnemen met ons supportteam via support@responsum.eu. Zij kunnen de API inschakelen, vragen beantwoorden die u mogelijk nog heeft na het lezen van de beschikbare documentatie en u in contact brengen met de juiste personen voor meer technische vragen, discussies of implementatieverzoeken.

Alle verdere documentatie gaat ervan uit dat de RESPONSUM API is ingeschakeld voor uw tenant.

Uw tenant key

Bij het gebruik van de RESPONSUM API bent u verplicht om bij elk verzoek uw daadwerkelijke tenant key te gebruiken zoals deze in ons systeem is gedefinieerd. Deze tenant key kan in de applicatie worden gevonden door te navigeren naar instellingen > configuratie > mijn organisatie en daar de hoogste organisatorische eenheid te openen, aangezien deze uw tenant weerspiegelt.

In de “Metadata” details van de tenant (twee pijltjes naar beneden bovenaan het zijpaneel), vindt u het alleen-lezen veld “Tenant key”.

Deze tenant key is ingesteld toen uw tenant werd aangemaakt en kan, in tegenstelling tot de tenantnaam, niet worden gewijzigd en is uniek voor deze specifieke tenant.

OpenAPI-specificaties voor de API van uw tenant

De RESPONSUM API die u gaat gebruiken, wordt specifiek voor uw tenant gegenereerd en bevat eventuele aanpassingen (aangepaste velden, aangepaste relaties, bedrijfsregels…) die mogelijk zijn gemaakt. Als zodanig kunnen de geleverde modellen per tenant verschillen.

Voor een eenvoudige integratie bieden we een specificatie-json-bestand aan volgens de OpenAPI-specificaties. U kunt dit laden door de [tenant key] in de volgende URL te vervangen door uw eigen, eerder gevonden tenant key: https://api.responsum.app/v1/[tenant key]/spec.json.

We bieden ook een visuele documentatie op basis van dit specificatiebestand om wat eenvoudige tests mogelijk te maken terwijl u vertrouwd raakt met de API. Deze is te vinden in onze app als u navigeert naar instellingen > integraties > API-documentatie.

Het eerste verzoek in die API-documentatie is ook om de OpenAPI-specificaties op te halen en is een van de weinige verzoeken die u zonder authenticatie kunt doen.

Authenticatie & autorisatie

Alle functionele verzoeken aan de RESPONSUM API verwachten dat er een API-token wordt meegegeven als onderdeel van het verzoek. Dit fungeert als zowel de authenticatie (door het token zelf te controleren) als de autorisatie (door de machtigingen van het gebruikersaccount te controleren dat aan dat token is gekoppeld).

Alle acties die via de API met dit token worden ondernomen, worden ook gelogd als zijnde uitgevoerd door de gebruiker die aan het API-token is gekoppeld; u treedt dus op als die gebruiker door het API-token te gebruiken.

Een API-token aanmaken

API-tokens kunnen alleen via onze app worden beheerd door naar instellingen > integraties > API-tokens te gaan.

Een API-token bestaat uit:

  • Een naam om het gemakkelijk te herkennen in de lijst en de tokens van elkaar te onderscheiden;
  • Een token-string, voor u gegenereerd en te gebruiken bij elk verzoek aan de API;
  • Een gebruikersmachtigingenniveau, gekoppeld aan een gebruikersaccount dat wordt geïmiteerd bij het gebruik van dit API-token. Als u dus machtigingen wilt verlenen of weigeren aan dit API-token, doet u dat door ze te verlenen of te weigeren aan het hier gekoppelde gebruikersaccount;
  • Een vervaldatum; als deze is ingesteld, werkt het token na deze datum niet meer.

Eenmaal aangemaakt, zou de token-string in een API-token onmiddellijk klaar voor gebruik moeten zijn. Als uw token-string om een of andere reden gecompromitteerd is, zal het opnieuw genereren van de token-string en het opslaan van het bijgewerkte API-token de oude token-string onmiddellijk ongeldig maken.

API-token meesturen met verzoeken

Zodra u een geldige API-token-string heeft, kunt u deze doorgeven aan de RESPONSUM API door een extra header aan uw verzoeken toe te voegen Api-Token waarvan de waarde uw API-token-string is.

Utility-verzoeken

UUID’s

Er zijn verschillende standaarden voor Universally Unique IDentifiers momenteel in gebruik en de RESPONSUM API zou de meeste moeten accepteren, aangezien onze validatie bestaat uit:

  • Ten minste 5 tekens lang
  • Bestaat alleen uit de tekens:
    • a tot z: abcdefghijklmnopqrstuvwxyz
    • 0 tot 9: 0123456789
    • streepje: -

Verder verwachten we dat de UUID uniek is, maar we zullen dit slechts beperkt controleren, in die zin dat het proberen aanmaken van een nieuw model of links met een UUID die al bestaat voor dat specifieke model of die link een foutmelding zal geven.

RESPONSUM zelf gebruikt een variant van het cuid2-algoritme, aangepast om gemakkelijker herkenbaar te zijn en aan ons voorkeursformaat te voldoen.

Om het u gemakkelijker te maken UUID’s te gebruiken die dit RESPONSUM-formaat volgen, hebben we een API-endpoint toegevoegd die u kunt gebruiken om tussen 1 en 1000 UUID’s te genereren die gegarandeerd uniek zijn en niet te onderscheiden van de UUID’s die intern door RESPONSUM worden gegenereerd.

Vervang de tenant key en het aantal in https://api.responsum.app/v1/[tenant key]/uuids/[amount] en voer er een GET-verzoek mee uit, waarbij u ervoor zorgt dat u de Api-Token header meestuurt. Als retourwaarde krijgt u een JSON-array met de UUID’s als stringwaarden.

Het voorbeeldproject bevat een voorbeeldoperatie die dit doet: https://github.com/RESPONSUM-BE/RESPONSUM-api-example/blob/main/src/operations/getUuids.ts

Linkformaat & algemeen principe

Links in RESPONSUM worden iets anders afgehandeld dan bij de meeste gangbare oplossingen, in die zin dat elke link als een eigen object in de link-collectie wordt opgeslagen, verwijzend naar de verschillende modellen die aan elkaar zijn gekoppeld, in plaats van verwijzingen op de modellen die naar andere modellen linken.

Links worden ook nooit bijgewerkt; ze kunnen alleen worden aangemaakt of verwijderd, aangezien het wijzigen van een gekoppeld model wordt beschouwd als het verwijderen van de oude link en het aanmaken van een nieuwe link.

Linkdefinities

Alle links zijn gebaseerd op verschillende linkdefinities; sommige hiervan zijn hardcoded en sommige kunnen door de gebruiker op maat worden gemaakt. Wanneer u de linkdefinities ophaalt via het GET https://api.responsum.app/v1/[tenant key]/link-definitions endpoint, krijgt u een JSON met een groot object, dat kan worden gezien als een woordenboek van alle linkdefinities.

Een voorbeeldfragment ter referentie:

{
  "stakeholder-stakeholderContact-contacts": {
    "stakeholder": {
      "modelType": "stakeholder",
      "oneOrMany": "one",
      "isRequired": false,
      "relationBehaviour": "reference-same-object"
    },
    "contact": {
      "modelType": "stakeholder-contact",
      "oneOrMany": "many",
      "isRequired": false,
      "relationBehaviour": "reference-same-object"
    }
  },
  <snipped-for-size>
}

Een linkType is een unieke beschrijvende sleutel voor deze specifieke linkdefinitie. In dit voorbeeld kunt u zien dat elke object-sleutel (“stakeholder-stakeholderContact-contacts”) het specifieke linkType van de linkdefinitie is.

Een role is een beschrijvende sleutel, uniek binnen de linkdefinitie, om de verschillende takken van de linkdefinitie te identificeren. In dit geval zijn “stakeholder” en “contact” de twee rollen; zoals u kunt zien, hoeven deze niet overeen te komen met het modeltype. Een ander voorbeeld is voor een zelfverwijzende link; deze rollen kunnen “parent” en “child” zijn.

Houd er ook rekening mee dat hoewel de meeste links slechts twee takken hebben, er meer dan twee zijn toegestaan en we al minstens één geval hebben waarbij we drieweg-links hebben.

Onder de rol heeft u een branch-definitie, die enkele eigenschappen van deze specifieke tak beschrijft:

  • Het modelType beschrijft welke modelTypes zijn toegestaan, dit kan zijn:
    • Een enkel modelType
    • Een array van modelTypes
    • De constante “all-models”
  • De oneOrMany beschrijft of er slechts één link mag worden toegestaan om naar deze combinatie van modeltype & uuid te linken, of dat er meerdere kunnen zijn
  • De isRequired beschrijft of deze link vereist is aan deze kant van de link. Indien waar, moet elk model van het type (of de types) gedefinieerd in modelType ten minste één link van dit linkType hebben
  • De relationBehaviour wordt voornamelijk intern gebruikt om te beslissen wat er met deze link moet gebeuren bij het dupliceren van modellen.

Op basis van de bovenstaande linkdefinitie kunnen we hetzelfde terugvinden in daadwerkelijke links.

Een voorbeeld van een link-object kan er als volgt uitzien:

{
  "uuid": "0fc0ea83-88df-49ec-a681-1ced0a6c0683",
  "type": "link",
  "linkType": "stakeholder-stakeholderContact-contacts",
  "links": [
    {
      "modelType": "stakeholder",
      "modelUuid": "55092a14-4d95-4665-ac50-eb687e535222",
      "role"     : "stakeholder"
    },
    {
      "modelType": "stakeholder-contact",
      "modelUuid": "ad95eded-3168-4a12-968d-456bc031af7e",
      "role"     : "contact"
    }
  ]
}

De eigenschappen uuid en type “link” zijn altijd aanwezig op elk object om het uniek te identificeren.

Het linkType komt overeen met een van de linkdefinities, in dit geval die in het voorbeeld van de linkdefinities.

De eigenschap ‘links’ is een array van de verschillende takken. Het aantal items in deze array zal altijd overeenkomen met het aantal rollen in de linkdefinitie, aangezien we voor elke rol een gekoppeld model verwachten.

  • De role komt overeen met een van de rollen zoals gedefinieerd in de bijbehorende linkdefinitie
  • Het modelType komt overeen met een van de toegestane modeltypes voor de bijbehorende linkdefinitie en roldefinitie
  • De uuid identificeert vervolgens naar welk specifiek model van het gegeven modeltype deze link verwijst

Verder kan er ook een metaData eigenschap zijn die een vrij vormgegeven gegevensobject kan bevatten met wat extra metadata over deze specifieke link, hoewel dit zelden wordt gebruikt.

Meestal krijgt u links als onderdeel van modellen, en op vergelijkbare wijze maakt of wijzigt u links bij het aanmaken of bijwerken van modellen.

Een link-eigenschap op een model zal, wanneer deze is ingevuld, worden beschouwd als de nieuwe lijst met links voor die eigenschap, ter vervanging van alle reeds bestaande links voor de eigenschap van dat model. Zorg er daarom bij het toevoegen van een nieuwe link aan een model voor dat u ook alle bestaande links opneemt die u wilt behouden.

Daarnaast zijn er ook drie endpoints om direct met links te communiceren.

Het GET https://api.responsum.app/v1/[tenant key]/links endpoint stelt u in staat om alle links op te halen, gefilterd op verschillende filters:

  • uuids, de uuids van de link-objecten
  • model-uuids, de uuids van de modellen waarnaar wordt verwezen in de link-objecten
  • relation-names, de linkTypes van the link-objecten

Deze kunnen worden opgegeven als queryparameters die een json-string-array als waarden bevatten.

Het POST https://api.responsum.app/v1/[tenant key]/create endpoint wordt weliswaar hoofdzakelijk gebruikt om modellen aan te maken, maar accepteert ook link-objecten en kan dus worden gebruikt om nieuwe links aan te maken.

Het DELETE https://api.responsum.app/v1/[tenant key]/link endpoint stelt u in staat om direct een of meer links te verwijderen waarvan u de uuid van het link-object kent.

Model-verzoeken

Alle gegevens in RESPONSUM worden opgeslagen in modellen; daarom zullen de meeste API-bewerkingen op deze modellen worden uitgevoerd.

Elk model moet een type en uuid hebben, die beide vereist zijn en na aanmaak niet kunnen worden gewijzigd.

Het type is een van onze vooraf gedefinieerde modellen, zoals “processing-activity” of “risk”.

Modeldefinitie

Dit verwijst naar een modeldefinitie met alle beschikbare velden, inclusief de aangepaste velden die in de applicatie zijn gedefinieerd. Voor type zal het het verwachte type als een string bevatten; zorg ervoor dat u exact deze stringwaarden gebruikt.

Voor basisvelden bevat het hun datatype en of ze verplicht zijn of niet.

Voor linkvelden bevat het een array van link-objecten.

Modellen weergeven

Voor elk modeltype hebben we een apart GET-endpoint in de API om alle modellen of een gefilterde lijst met modellen voor dat type op te halen.

Voor filtering kunt u een URI-gecodeerde queryparameter “param-filter” toevoegen aan de GET-URL die een JSON-object met het filter bevat. Dit filter heeft als eigenschap de naam van de eigenschap waarop u wilt filteren en als waarde een array van alle eigenschapswaarden waarop u wilt matchen.

Als u bijvoorbeeld “advice” wilt filteren om modellen te vinden waarvan de status “new” of “ongoing” is, maakt u als volgt een json-filterobject aan: {"status": ["new", "ongoing"]}. Daarna codeert u dit als URI voor de waarde van de param-filter queryparameter, wat u het volgende GET-verzoek oplevert: https://api.responsum.app/v1/[tenant key]/advice?param-filter=%7B%22status%22%3A%20%5B%22new%22%2C%20%22ongoing%22%5D%7D

U kunt ook filters op meerdere eigenschappen combineren door extra eigenschappen aan het json-filterobject toe te voegen, zoals: {"status": ["new", "ongoing"], "isObsolete": [false]}. Dit retourneert een array van overeenkomende modellen of een lege array als er geen modellen worden gevonden.

Het voorbeeldproject bevat een voorbeeldoperatie die dit doet: https://github.com/RESPONSUM-BE/RESPONSUM-api-example/blob/main/src/operations/getCountriesByFilter.ts

Een enkel model ophalen

Voor elk modeltype hebben we een apart GET-endpoint in de API om een specifiek model voor dat type op te halen op basis van zijn uuid. Voeg de uuid gewoon toe aan de URL van het modeltype, wat u een GET-verzoek als volgt oplevert: https://api.responsum.app/v1/[tenant key]/advice/raou8qtt-60od-n7t5-g8el-c0sy99r0ppag

Dit retourneert dat enkele model of een 404 ‘no model found’ foutmelding.

Om modellen en links tussen die modellen aan te maken, hebben we één generiek POST https://api.responsum.app/v1/[tenant key]/create endpoint, omdat we het mogelijk willen maken om in één keer een set van meerdere gerelateerde modellen en de links daartussen aan te maken, om de kans op onvolledige sets als gevolg van falende validatie of iets dergelijks te verkleinen.

Het create-endpoint accepteert een array van modellen, die elk het type, een uuid en alle vereiste eigenschappen voor dat modeltype moeten hebben.

Voor de link-eigenschappen op de modellen kunt u ook een array van link-objecten opnemen, waarvan we de unie over de geleverde modellen nemen en deze invoegen. Dit betekent dat als u twee modellen heeft die naar elkaar linken, onze API alleen het link-object dat die twee verbindt op een van de modellen vereist om te begrijpen dat het moet worden toegevoegd; het toevoegen op beide modellen maakt echter geen verschil.

Het voorbeeldproject bevat een voorbeeldoperatie die dit doet.

Om modellen en links tussen die modellen bij te werken, hebben we één generiek PATCH https://api.responsum.app/v1/[tenant key]/update endpoint, omdat we het mogelijk willen maken om in één keer een set van meerdere gerelateerde modellen en de links daartussen bij te werken.

Het update-endpoint accepteert een array van modellen, waarbij elk model alleen het type, de uuid en de velden die worden bijgewerkt moet bevatten.

Voor de link-eigenschappen op de modellen is dit wederom een array van link-objecten, waarvan we de unie over de geleverde modellen nemen en vervolgens alle links verwijderen die geen deel uitmaken van deze unie, alvorens eventuele links in deze unie toe te voegen die nog niet in de database staan. Dit betekent dat als u een link wilt toevoegen aan een model-eigenschap, u ook de link-objecten van de bestaande model-eigenschap moet opnemen, anders worden deze bestaande links verwijderd.

Het voorbeeldproject bevat een voorbeeldoperatie die dit doet.

Versiebeheer van modellen

De meeste RESPONSUM-modellen hebben versiebeheer ingeschakeld, wat betekent dat elke wijziging aan deze modellen wordt geregistreerd en deze versies kunnen worden bevroren, goedgekeurd, enz.

Alle versies voor een model ophalen

U kunt alle versiewijzigingen voor een bepaald model ophalen met het volgende GET-verzoek: https://api.responsum.app/v1/[tenant key]/version/[model type]/[model uuid]. Dit retourneert zowel “unversioned” (concept) als elke bevroren versie met de extra informatie over die versie, zoals de versiestatus, wie de versie heeft aangemaakt, wie deze heeft goedgekeurd, enz.

Levenscyclus van een versie

Niet-geversioneerde wijzigingen

Alle wijzigingen beginnen als niet-geversioneerde wijzigingen. Elke keer dat een model wordt aangemaakt of bijgewerkt, leggen we de vorige en nieuwe waarde voor de gewijzigde eigenschappen vast. Ook wie de wijziging heeft aangebracht, wanneer dit is gebeurd en wat voor soort bewerking het was.

De lijst met bewerkingen bevat enkele veelvoorkomende waarden zoals ‘create’, ‘update’, ‘delete’, ‘merge’, ‘import’, ‘history-restoration’ en ‘update-link’, maar kan ook speciale waarden bevatten zoals ‘V2-create’ voor onze legacy-import. Er kunnen op elk moment nieuwe waarden worden toegevoegd, afhankelijk van toekomstige ontwikkelingen.

Bevriezen

Op elk moment kunnen de wijzigingen voor een model worden bevroren met POST https://api.responsum.app/v1/[tenant key]/version/[model type]/[model uuid]/freeze, wat een nieuwe versie zal aanmaken met reviewStatus ‘frozen’ en alle eventuele niet-geversioneerde wijzigingen zal bevatten. Als er geen niet-geversioneerde wijzigingen waren, wordt er geen nieuwe versie aangemaakt.

U kunt ook een versienaam opgeven bij het bevriezen, maar als er geen wordt opgegeven, wordt er een berekend op basis van de momenteel bestaande versies.

Op dit punt kunnen bepaalde personen met de juiste machtiging deze versie al goedkeuren of afwijzen, maar het belangrijkste is dat eventuele nieuwe wijzigingen als niet-geversioneerde wijzigingen zullen worden toegevoegd, terwijl wijzigingen in deze versie nooit meer zullen veranderen.

Goedkeuring aanvragen

Om een versie goedgekeurd of afgewezen te krijgen, kunt u specifieke personen vragen deze te beoordelen. Hiervoor kunt u een PUT https://api.responsum.app/v1/[tenant key]/version/[model type]/[model uuid]/request-approval uitvoeren met een versie-uuid & “accountable user”-uuid. Dit zal meldingen activeren voor deze persoon om deze versie te beoordelen en ofwel goed te keuren of af te wijzen.

Goedkeuren of Afwijzen

U kunt versies ook goedkeuren of afwijzen via de API als de gebruiker die aan uw token is gekoppeld over voldoende machtigingen beschikt.

Dit kan worden gedaan met de twee PUT-endpoints https://api.responsum.app/v1/[tenant key]/version/[model type]/[model uuid]/approve of https://api.responsum.app/v1/[tenant key]/version/[model type]/[model uuid]/reject, waarbij wederom de versie-uuid vereist is die u wilt goedkeuren of afwijzen.

Webhooks

Soms wilt u ook op de hoogte worden gesteld wanneer modellen worden aangemaakt of bijgewerkt. Hiervoor hebben we webhooks die u kunt configureren door naar instellingen > integraties > webhooks te gaan.

Voor het gebruiksgemak kunnen webhooks worden in- of uitgeschakeld; alleen ingeschakelde webhooks zullen aanroepen activeren.

De naam wordt puur gebruikt om de webhooks van elkaar te onderscheiden.

De opgegeven URL zal worden aangeroepen met de opgegeven headers; dit zal een POST-verzoek zijn dat een json-body bevat met de changeAction, modelType en uuids (een array van uuids).

U kunt kiezen uit de volgende wijzigingsacties; de webhook wordt alleen aangeroepen voor de geselecteerde acties:

  • ‘link-deleted’: wanneer een link wordt verwijderd uit een of meer van de eigenschappen
  • ‘link-created’: wanneer een link wordt toegevoegd voor een of meer van de eigenschappen
  • ‘item-deleted’: wanneer het item wordt verwijderd
  • ‘item-meta-data-updated’: wanneer berekende eigenschappen worden bijgewerkt, bijv. laatst bijgewerkt door, beoordelingsstatus, enz.
  • ‘item-base-data-updated’: wanneer de basiseigenschappen worden bijgewerkt, bijv. naam, isObsolete, enz.
  • ‘item-created’: wanneer het item wordt aangemaakt

U kunt de sub-module selecteren waarvoor de webhook moet worden geactiveerd; dit kan zo verfijnd zijn als een enkel modeltype of zo breed als elk model in de applicatie.

Op basis van onze interne logica kunt u kort na elkaar meerdere webhook-aanroepen ontvangen voor hetzelfde modeltype & uuid, nadat een gebruiker heeft opgeslagen. Het toevoegen van een link en het instellen van een eigenschap zal bijvoorbeeld een ‘item-base-data-updated’, ‘item-meta-data-updated’ en ‘link-created’ aanroep triggeren.

Voorbeeldapplicatie

https://github.com/RESPONSUM-BE/RESPONSUM-api-example

Zie de readme om aan de slag te gaan. Zodra u het draaiende heeft en http://localhost:3000 opent, zou u iets als dit moeten zien:

Terwijl u vervolgens de verschillende bewerkingen uitvoert, ziet u aan de rechterkant van de pagina een logboek van de bewerkingen.

U kunt al deze bewerkingen ook vinden in de map src\operations\

Was this article helpful?

Related Articles