Funktion Flagga Rättighet

​

Vad som levereras

• Vid köp skapar Dodo Payments grantet direkt i Delivered. Det hamnar aldrig i Pending, kräver ingen åtgärd från kunden och har inget leveranssteg som kan misslyckas.
• Grantet innehåller en typad payload för feature: { "feature_type": "boolean", "feature_id": "advanced_reports" }. Din applikation läser feature_id för att avgöra vad som ska låsas upp.
• Uppsägning, återbetalning eller en manuell återkallelse flyttar grantet till Revoked, och flaggan försvinner från kundens levererade grants.

​

Skapa en feature flag

1

Open Entitlements

Gå till Entitlements i Dodo Payments dashboard och klicka på + för att skapa en ny entitlement. Välj sedan Feature Flags.

2

Name the Flag

Ange ett Display Name för dashboarden och rapporterna, samt en Description så att ditt team vet vad flaggan styr. Feature ID är det som din applikation kontrollerar. Dashboarden fyller i det utifrån visningsnamnet (till exempel blir “API access” till api_access), och du kan redigera det. Det får inte innehålla mellanslag.

3

Add Metadata (Optional)

Aktivera Meta Data för att bifoga nyckel-värde-konfiguration, till exempel gränser, nivånamn eller kvoter, som din applikation tar emot tillsammans med flaggan. Klicka på Add Entry för varje par. Se Bifoga gränser med metadata.

4

Confirm

Klicka på Bekräfta. Flaggan visas i din rättighetslista, redo att bifogas till produkter.

​

Koppla till en produkt

​

Obligatorisk konfiguration

​

Skapa via API

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env['DODO_PAYMENTS_API_KEY'],
  environment: 'test_mode',
});

const entitlement = await client.entitlements.create({
  name: 'Advanced Reports',
  integration_type: 'feature_flag',
  integration_config: {
    feature_type: 'boolean',
    feature_id: 'advanced_reports',
  },
  metadata: {
    tier: 'pro',
    monthly_report_limit: 100,
  },
});

import os
from dodopayments import DodoPayments

client = DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
    environment="test_mode",
)

entitlement = client.entitlements.create(
    name="Advanced Reports",
    integration_type="feature_flag",
    integration_config={
        "feature_type": "boolean",
        "feature_id": "advanced_reports",
    },
    metadata={
        "tier": "pro",
        "monthly_report_limit": 100,
    },
)

// client is a *dodopayments.Client, for example from
// dodopayments.NewClient(option.WithEnvironmentTestMode()); ctx is a context.Context.
client.Entitlements.New(ctx, dodopayments.EntitlementNewParams{
  Name:            dodopayments.F("Advanced Reports"),
  IntegrationType: dodopayments.F(dodopayments.EntitlementIntegrationTypeFeatureFlag),
  IntegrationConfig: dodopayments.F[dodopayments.IntegrationConfigUnionParam](
    dodopayments.IntegrationConfigFeatureFlagConfigParam{
      FeatureType: dodopayments.F(dodopayments.FeatureTypeBoolean),
      FeatureID:   dodopayments.F("advanced_reports"),
    },
  ),
})

​

Bifoga gränser med metadata

• Om du redigerar entitlementens metadata senare påverkar det endast framtida grants. Kunderna behåller gränserna som de köpte.
• Varje grant returnerar sin ögonblicksbild i fältet metadata, så ett API-anrop ger dig både flaggan och dess konfiguration.

​

Kontrollera en kunds funktioner

const features = new Map<string, Record<string, unknown>>();

for await (const grant of client.customers.listEntitlementGrants('cus_abc123', {
  integration_type: 'feature_flag',
  status: 'Delivered',
})) {
  if (grant.feature) {
    features.set(grant.feature.feature_id, grant.metadata ?? {});
  }
}

if (features.has('advanced_reports')) {
  const limit = features.get('advanced_reports')?.monthly_report_limit;
  // unlock the dashboard, enforce the limit
}

page = client.customers.list_entitlement_grants(
    customer_id="cus_abc123",
    integration_type="feature_flag",
    status="Delivered",
)

# Iterating the page fetches every page of results.
features = {
    grant.feature.feature_id: grant.metadata
    for grant in page
    if grant.feature
}

if "advanced_reports" in features:
    limit = features["advanced_reports"].get("monthly_report_limit")

iter := client.Customers.ListEntitlementGrantsAutoPaging(
  ctx, "cus_abc123",
  dodopayments.CustomerListEntitlementGrantsParams{
    IntegrationType: dodopayments.F(dodopayments.CustomerListEntitlementGrantsParamsIntegrationTypeFeatureFlag),
    Status:          dodopayments.F(dodopayments.CustomerListEntitlementGrantsParamsStatusDelivered),
  },
)

features := map[string]bool{}
for iter.Next() {
  grant := iter.Current()
  if grant.Feature.FeatureID != "" {
    features[grant.Feature.FeatureID] = true
  }
}
if err := iter.Err(); err != nil {
  panic(err.Error())
}

​

Livscykel

​

Webhooks

• entitlement_grant.created anländer redan i tillståndet Delivered, med payloaden feature. Aktivera funktionen.
• entitlement_grant.delivered utlöses när ett tidigare återkallat grant återställs. Aktivera funktionen igen.
• entitlement_grant.revoked betyder att åtkomsten har dragits in. Inaktivera funktionen och kontrollera revocation_reason för att välja hur du ska kommunicera detta.

import express from 'express';
import DodoPayments from 'dodopayments';

// Reads DODO_PAYMENTS_API_KEY and DODO_PAYMENTS_WEBHOOK_KEY from the environment.
const client = new DodoPayments({ environment: 'test_mode' });
const app = express();

app.post('/webhooks/dodo', express.raw({ type: 'application/json' }), async (req, res) => {
  let event: DodoPayments.UnwrapWebhookEvent;
  try {
    event = client.webhooks.unwrap(req.body.toString(), {
      headers: req.headers as Record<string, string>,
    });
  } catch {
    res.sendStatus(400); // invalid signature
    return;
  }

  const grant = 'feature' in event.data ? event.data : null;

  if (event.type.startsWith('entitlement_grant.') && grant?.feature) {
    const enabled = event.type !== 'entitlement_grant.revoked';

    // db is your application's database client.
    await db.customerFeatures.upsert({
      customerId: grant.customer_id,
      featureId: grant.feature.feature_id,
      enabled,
      config: grant.metadata ?? {},
    });
  }

  res.sendStatus(200);
});

​

Exempel: Pro-planen låser upp avancerade rapporter

1. Skapa flaggan. Ange feature_id: advanced_reports med metadata { "tier": "pro", "monthly_report_limit": 100 }.
2. Koppla den till din Pro Plan-prenumerationsprodukt.
3. En kund prenumererar. Dodo Payments skapar ett grant av typen Delivered och utlöser entitlement_grant.created. Din webhook-handler aktiverar advanced_reports för kunden med en gräns på 100.
4. Din app styr åtkomsten till funktionen. När dashboarden läses in kontrollerar du den cachade funktionsuppsättningen (eller anropar listEntitlementGrants) och visar rapportfliken endast när advanced_reports finns.
5. Kunden säger upp prenumerationen. Dodo Payments återkallar grantet och utlöser entitlement_grant.revoked, och din handler inaktiverar funktionen. Om en prenumeration senare återställs genom dunning återställer entitlement_grant.delivered funktionen utan kodändringar.

​

Rekommenderade metoder

• Använd stabila feature IDs i snake_case. Din applikationskod kontrollerar dessa strängar, så att byta namn på en av dem är en breaking change på båda sidor.
• Använd en flagga per funktion. Föredra advanced_reports och api_access som två entitlements framför en enda pro_bundle, så att återkallelser och plankombinationer förblir tydliga.
• Låt webhooks styra status och verifiera med API:et. Webhooks håller din databas uppdaterad. List-endpointen är sanningskällan för avstämningsjobb och cache-missar.
• Behandla Revoked som omedelbart. En återkallad flagga betyder att kunden inte längre betalar för funktionen. Styr åtkomsten vid nästa request, inte nästa session.
• Lägg gränser i metadata, inte i kod. När en kvot ändras behöver du då endast redigera entitlementen. Nya kunder får det nya värdet, och befintliga grants behåller sin köpta ögonblicksbild.