कार्ड

यह पेज अंग्रेज़ी से अनुवादित है। अगर दोनों में अंतर हो, तो अंग्रेज़ी पेज सही है। अंग्रेज़ी पेज पढ़ें

कार्ड एलिमेंट की एक छोटी सूची है जिसे Lingara अपनी शैली में दिखाता है। इसमें कोई इनपुट, छवि, स्क्रिप्ट या मार्कअप नहीं होता। कोई ऐप शिक्षार्थी की स्क्रीन पर अपना कोड या अपना रूप-रंग नहीं डाल सकता, इसलिए हर कार्ड बाकी Lingara जैसा ही लगता है। आपका जवाब JSON होता है: एक card, जिसमें उसके elements होते हैं, और वैकल्पिक रूप से एक tutor_note (देखें ट्यूटर नोट)।

एलिमेंट

हर एलिमेंट का एक type होता है, जो इन आठ में से एक है:

एलिमेंट	फ़ील्ड	यह क्या दिखाता है
`heading`	`text`, `level`	एक शीर्षक। `level` 1 या 2 होता है, और कोई भी अन्य मान 2 बन जाता है। इसका टेक्स्ट अधिकतम 80 वर्णों का होता है।
`text`	`text`, `lang`	अधिकतम 600 वर्णों का एक अनुच्छेद। यही एकमात्र जगह है जहाँ लाइन ब्रेक बना रहता है।
`term`	`word`, `reading`, `gloss`, `lang`	सीखने के लिए एक शब्द। केवल `word` आवश्यक है। शब्द अधिकतम 60 वर्णों का, उच्चारण 120 का और अर्थ 160 का होता है।
`list`	`items`	अधिकतम 20 आइटम। हर आइटम एक `text` या एक `term` होता है, जिसमें उसी नाम के एलिमेंट जैसे ही फ़ील्ड होते हैं।
`progress`	`value`, `label`	एक प्रगति बार। `value` 0 से 1 तक होता है, और लेबल अधिकतम 60 वर्णों का होता है।
`divider`		कार्ड के हिस्सों के बीच एक रेखा।
`button`	`label`, `action`, `style`	एक बटन जो अपना `action` आपके सर्वर को भेजता है। `style` `primary` या `secondary` होता है, और लेबल अधिकतम 32 वर्णों का होता है।
`link`	`label`, `url`	एक लिंक जिसे शिक्षार्थी Lingara के पूछने के बाद अपने ब्राउज़र में खोलता है। लेबल अधिकतम 60 वर्णों का होता है।

lang एक भाषा टैग है, जैसे ja, ताकि Lingara सही लिपि दिखाए। जो मान भाषा टैग नहीं है, उसे हटा दिया जाता है।

सीमाएँ

एक कार्ड में अधिकतम 24 एलिमेंट होते हैं। पहले 24 के बाद के एलिमेंट हटा दिए जाते हैं।
एक सूची में अधिकतम 20 आइटम होते हैं। पहले 20 के बाद के आइटम हटा दिए जाते हैं, और खाली सूची हटा दी जाती है।
एक कार्ड में अधिकतम 4 बटन होते हैं। पहले 4 के बाद के बटन हटा दिए जाते हैं।
अपनी सीमा से लंबा टेक्स्ट फ़िट होने के लिए काट दिया जाता है और … पर समाप्त होता है। वर्णों को Unicode स्केलर मानों के रूप में गिना जाता है।
हर स्ट्रिंग से कंट्रोल कैरेक्टर और दिशा ओवरराइड हटा दिए जाते हैं।
जिस लिंक का पता HTTPS नहीं है, जिसमें उपयोगकर्ता नाम है, या जो किसी IP पते की ओर इशारा करता है, उसे हटा दिया जाता है।
जिस बटन का action 64 वर्णों से लंबा है, या जो अक्षरों, अंकों, _, ., : और - के अलावा कुछ भी उपयोग करता है, उसे हटा दिया जाता है।
जिस एलिमेंट में इन नियमों के बाद कोई टेक्स्ट नहीं बचता, उसे हटा दिया जाता है।

ये नियम उदार हैं: जो फ़िट नहीं होता उसे Lingara काट देता है या हटा देता है और बाकी को दिखाता है। किट आपके जवाब देने से पहले यही नियम लागू करते हैं, ताकि आप देख सकें कि क्या बदलेगा।

सख़्त पार्सिंग

शब्दावली बंद है। कोई अज्ञात एलिमेंट टाइप, ऐसा फ़ील्ड जो किसी एलिमेंट में नहीं होता, गलत JSON टाइप का मान, या ऐसा जवाब जो JSON है ही नहीं, पूरे जवाब को फ़ॉलबैक में बदल देता है। Lingara कभी भी किसी ऐसे कार्ड का हिस्सा नहीं दिखाता जिसे वह पढ़ नहीं सका।

आकार और समय

जवाब अधिकतम 32 KiB का हो सकता है। Lingara आपके सर्वर को रेंडर का जवाब देने के लिए 3 सेकंड और ऐक्शन का जवाब देने के लिए 5 सेकंड देता है, और दोनों में से किसी को भी दोबारा नहीं आज़माता। जवाब का स्टेटस 200 और कंटेंट टाइप JSON होना चाहिए। रीडायरेक्ट का पालन नहीं किया जाता।

बटन और ऐक्शन

जब शिक्षार्थी कोई बटन दबाता है, तो Lingara आपके सर्वर को एक ऐक्शन अनुरोध भेजता है जिसमें उस बटन का action होता है। आपका सर्वर एक नए कार्ड के साथ जवाब देता है, जो पुराने कार्ड की जगह ले लेता है। एक ही प्रेस दो बार पहुँच सकता है, इसलिए हर ऐक्शन को दोहराने के लिए सुरक्षित बनाएँ।

जब कार्ड विफल होता है

जब Lingara को ऐसा कार्ड नहीं मिलता जिसे वह दिखा सके, तो शिक्षार्थी अपनी भाषा में Lingara का अपना “इस ऐप ने जवाब नहीं दिया” कार्ड देखता है, या आपका आखिरी सही कार्ड, जिस पर अद्यतित नहीं होने का निशान लगा होता है। शिक्षार्थी को कभी नहीं बताया जाता कि क्यों। केवल आप, ऐप के मालिक के रूप में, कारण देखते हैं:

आपका जवाब: invalid (ऐसा कार्ड नहीं जिसे Lingara पढ़ सके), empty (सीमाओं के बाद दिखाने के लिए कुछ नहीं बचा) या too_large (32 KiB से अधिक)।
आपके सर्वर तक पहुँचना: timeout, http_error (200 के अलावा कोई भी स्टेटस), transport (कनेक्शन या TLS विफलता, जैसे समाप्त हो चुका प्रमाणपत्र) या blocked (ऐसा render_url जो किसी निजी या IP-लिटरल पते पर ले जाता है)।
Lingara की ओर से: unavailable (Lingara अनुरोध पर हस्ताक्षर नहीं कर सका) या busy (पहले से बहुत अधिक अनुरोध चल रहे हैं)।

TypeScriptRustGoJavaKotlinRubyPHP

TypeScript

function todayCard(streak: number): Card {
  return card()
    .heading("Today's five", 1)
    .term({ word: "雨", reading: "yǔ", gloss: "rain", lang: "zh" })
    .list([item.text("Review 3 words"), item.term({ word: "二", reading: "èr" })])
    .button(`Done (${streak})`, "done")
    .build(); // Throws CardLimitError naming the rule the relay would clamp.
}

Rust

fn today_card(title: &str, lang: &str) -> Result<lingara_apps::Card, BoxError> {
    Ok(card()
        .heading(title, 1)
        .term(Term::new("雨").reading("yǔ").gloss("rain").lang(lang))
        .list([item::text("Say it aloud"), item::term(Term::new("下雨").gloss("to rain"))])
        .button("Next word", "next")
        .build()?)
}

card, err := lingaraapps.NewCard().
	Heading("Today", 1).
	Term(lingaraapps.Term{Word: "雨", Reading: "yǔ", Gloss: "rain", Lang: "zh"}).
	List(
		lingaraapps.Item.Text("Say it aloud three times."),
		lingaraapps.Item.Term(lingaraapps.Term{Word: "雨天", Gloss: "rainy day", Lang: "zh"}),
	).
	Button("Next", "next").
	Build()
if err != nil {
	// A *lingaraapps.CardLimitError names the rule the card breaks,
	// such as text_length or list_items. Nothing is cut for you.
	return lingaraapps.Card{}, err
}

Java

import com.getlingara.apps.Card;
import com.getlingara.apps.Item;

Card card =
    Card.card()
        .heading("Today's five", 1)
        .term("雨", "yǔ", "rain", "zh")
        .list(Item.text("Say it aloud"), Item.term("二", "èr", "two", "zh"))
        .button("Next", "next")
        .build(); // a CardLimitException names the first rule the card breaks

Kotlin

import com.getlingara.apps.kotlin.Card
import com.getlingara.apps.kotlin.card

val c =
    card {
        heading("Today's five", 1)
        term("雨", reading = "yǔ", gloss = "rain", lang = "zh")
        list(item.text("Say it aloud"), item.term("二", reading = "èr", gloss = "two", lang = "zh"))
        button("Next", "next")
    } // a CardLimitException names the first rule the card breaks

Ruby

def self.today_card(streak)
  Lingara::Apps.card
    .heading("Today's five", 1)
    .term(word: "雨", reading: "yǔ", gloss: "rain", lang: "zh")
    .list([Lingara::Apps.item.text("Review 3 words"), Lingara::Apps.item.term(word: "二", reading: "èr")])
    .button("Done (#{streak})", "done")
    .build # Raises Lingara::Apps::CardLimitError naming the rule Lingara would clamp.
end

PHP

use Lingara\Apps\Card;
use Lingara\Apps\Generated\Card as CardModel;
use Lingara\Apps\Item;

function todayCard(int $streak): CardModel
{
    return Card::create()
        ->heading("Today's five", 1)
        ->term('雨', reading: 'yǔ', gloss: 'rain', lang: 'zh')
        ->list([Item::text('Review 3 words'), Item::term('二', reading: 'èr')])
        ->button("Done ({$streak})", 'done')
        ->build(); // Throws CardLimitException naming the rule the relay would clamp.
}