Context en toestemming

Deze pagina is vertaald uit het Engels. Als de twee verschillen, is de Engelse pagina juist. Lees de Engelse pagina

Je app komt alleen iets over een leerder te weten via contextslices. Elke slice is een klein record met vaste velden. Je manifest somt de slices op waarom hij vraagt, de leerder stemt met elk ervan in wanneer hij je app installeert, en Lingara stuurt een slice alleen zolang beide nog gelden.

De slices

Slice	Veld	Wat het bevat
`languages`	`source_lang`	De taal van waaruit de leerder studeert, als taaltag zoals `en`.
	`target_lang`	De taal die hij leert.
	`level`	Zijn niveau daarin, van 1 tot 9, als hij er een heeft ingesteld.
`plan_summary`	`plan_id`	De id van zijn nieuwste lesplan, waarmee je het ene plan van het andere onderscheidt. Je app kan het plan er niet mee ophalen, omdat het token van je app je eigen account leest, niet dat van de leerder.
	`title`	De gegenereerde titel van het plan, maximaal 120 tekens, als het er een heeft.
	`target_lang`	De taal die het plan onderwijst.
	`set_count`	Hoeveel sets het plan heeft, maximaal 200.
	`sets_completed`	Hoeveel van die sets de leerder heeft afgerond.
`review_due`	`due`	Hoeveel flashcards er nu te herhalen zijn, maximaal 100000.
	`learned`	Hoeveel woorden hij heeft geleerd, maximaal 100000.
`tutor_topic`	`topic`	Waar zijn nieuwste tutorgesprek over gaat, van 1 tot 120 tekens. Het komt uit de titel van een plan of het scherm waarop hij zich bevindt, nooit uit zijn eigen woorden.

Wat geen enkele slice bevat

Geen enkele slice bevat een e-mailadres, een naam, een gebruikers-id of iets dat de leerder heeft getypt. Je app leert wie de leerder is uit de subject van het verzoek, een stabiele waarde die voor elke app anders is. Het token van je app leest je eigen account, nooit dat van de leerder, dus de slices zijn alles wat je app over hem weet.

Toestemming

De leerder stemt met elke slice in wanneer hij je app installeert. Om te wijzigen waarmee hij heeft ingestemd, deïnstalleert hij je app en installeert hij hem opnieuw.
Als je je manifest aanpast om om minder slices te vragen, stoppen de slices die je hebt geschrapt meteen.
Als je het aanpast om om meer te vragen, bereiken de nieuwe slices geen enkele leerder totdat hij opnieuw installeert.
Lingara controleert de toestemming opnieuw bij elk verzoek en laat elke slice weg waarmee de leerder niet heeft ingestemd of waar je manifest niet meer om vraagt. Een slice die niet in zijn record past, wordt ook weggelaten, nooit het hele verzoek.

Het voorbeeld hieronder bouwt zijn regel op uit de slices die het heeft gekregen en roept geen API aan.

TypeScriptRustGoJavaKotlinRubyPHP

TypeScript

// The app's own client reads its owner's account, never the learner's. The
// slices are all a render knows about the learner.
function planLine(request: AppRenderRequest): string {
  let line = "";
  for (const slice of request.context) {
    // A slice is present only when the learner agreed to share it.
    if (slice.kind === "languages") line += `${slice.source_lang} → ${slice.target_lang}. `;
    if (slice.kind === "plan_summary") line += `${slice.sets_completed}/${slice.set_count} sets.`;
  }
  return line;
}

Rust

// The app's own client reads its owner's account, never the learner's. The
// slices are all a render knows about the learner.
/// The learner's target language and, when they shared their plan, its
/// `(sets_completed, set_count)`.
fn shared_plan(request: &AppRenderRequest) -> (String, Option<(u32, u32)>) {
    let (mut target_lang, mut progress) = (String::from("zh"), None);
    for slice in &request.context {
        match slice {
            ContextSlice::Languages(languages) => target_lang = languages.target_lang.clone(),
            ContextSlice::PlanSummary(summary) => progress = Some((summary.sets_completed, summary.set_count)),
            _ => {}
        }
    }
    (target_lang, progress)
}

// The app's own client reads its owner's account, never the learner's.
// The slices are all a render knows about the learner.
//
// Each slice is present only when the learner agreed to share it.
card := lingaraapps.NewCard().Heading("Your plan", 1)
for _, slice := range req.Context {
	switch s := slice.(type) {
	case lingaraapps.ContextSliceLanguages:
		card.Text(fmt.Sprintf("Learning %s from %s", s.TargetLang, s.SourceLang))
	case lingaraapps.ContextSlicePlanSummary:
		card.Text(fmt.Sprintf("%d of %d sets done", s.SetsCompleted, s.SetCount))
	}
}

Java

import com.getlingara.apps.Card;
import com.getlingara.apps.Reply;
import com.getlingara.apps.model.AppRenderRequest;
import com.getlingara.apps.model.ContextSlice;
import com.getlingara.apps.model.ContextSliceLanguages;
import com.getlingara.apps.model.ContextSlicePlanSummary;

// The app's own client reads its owner's account, never the learner's. The slices are all a
// render knows about the learner.
static Reply render(AppRenderRequest request) {
  Card.Builder card = Card.card();
  // A slice is present only when the learner agreed to share it; the context is read-only.
  for (ContextSlice slice : request.getContext()) {
    if (slice instanceof ContextSliceLanguages languages) {
      card.heading("Learning " + languages.targetLang(), 1);
    } else if (slice instanceof ContextSlicePlanSummary summary) {
      card.text(summary.setsCompleted() + " of " + summary.setCount() + " sets done");
    }
  }
  return card.heading("Today", 2).build();
}

Kotlin

import com.getlingara.apps.kotlin.Reply
import com.getlingara.apps.kotlin.card
import com.getlingara.apps.kotlin.model.AppRenderRequest
import com.getlingara.apps.kotlin.model.ContextSliceLanguages
import com.getlingara.apps.kotlin.model.ContextSlicePlanSummary

// The app's own client reads its owner's account, never the learner's. The slices are all a
// render knows about the learner.
fun renderWithContext(request: AppRenderRequest): Reply {
    // A slice is present only when the learner agreed to share it; the context is read-only.
    val languages = request.context.filterIsInstance<ContextSliceLanguages>().firstOrNull()
    val summary = request.context.filterIsInstance<ContextSlicePlanSummary>().firstOrNull()
    return card {
        heading("Learning ${languages?.targetLang ?: "today"}", 1)
        if (summary != null) {
            text("${summary.setsCompleted} of ${summary.setCount} sets done")
        }
    }
}

Ruby

# The app's own client reads its owner's account, never the learner's. The
# slices are all a render knows about the learner.
#
# A slice is present only when the learner agreed to share it.
request.context.filter_map do |slice|
  case slice
  in Lingara::Apps::ContextSliceLanguages(source_lang:, target_lang:)
    "#{source_lang} → #{target_lang}."
  in Lingara::Apps::ContextSlicePlanSummary(sets_completed:, set_count:)
    "#{sets_completed}/#{set_count} sets."
  else nil
  end
end.join(" ")

PHP

use Lingara\Apps\Generated\ContextSliceLanguages;
use Lingara\Apps\Generated\ContextSlicePlanSummary;

function planLine(AppRenderRequest $request): string
{
    // The app's own client reads its owner's account, never the learner's. The
    // slices are all a render knows about the learner.
    $line = '';
    // A slice is present only when the learner agreed to share it.
    foreach ($request->getContext() as $slice) {
        if ($slice instanceof ContextSliceLanguages) {
            $line .= "{$slice->sourceLang} → {$slice->targetLang}. ";
        } elseif ($slice instanceof ContextSlicePlanSummary) {
            $line .= "{$slice->setsCompleted}/{$slice->setCount} sets.";
        }
    }
    return $line;
}

Zie ook

Lingara API-bibliotheken