comunes/tane
1
0
Fork 0
Code Issues Pull requests Projects Releases 7 Packages Wiki Activity Actions

Merge branch 'main' into spike/block2-derisking

Browse source
This commit is contained in:
vjrj 2026-07-10 03:06:30 +02:00
commit c3b904ce71
24 changed files with 69558 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

67617
apps/app_seeds/assets/catalog/species.json
View file

File diff suppressed because it is too large Load diff

4
apps/app_seeds/lib/data/species_catalog.dart
View file

@ -18,10 +18,10 @@ List<SpeciesSeed> parseSpeciesCatalog(String jsonString) {
return SpeciesSeed(
scientificName: e['scientific_name'] as String,
family: e['family'] as String?,
wikidataQid: e['wikidata_qid'] as String?,
gbifKey: (e['gbif_key'] as num?)?.toInt(),
commonNames: common,
viabilityYears: (e['viability_years'] as num?)?.toInt(),
gbifKey: (e['gbif_key'] as num?)?.toInt(),
wikidataQid: e['wikidata_qid'] as String?,
);
}).toList();
}

299
apps/app_seeds/lib/data/species_repository.dart
View file

@ -2,33 +2,35 @@ import 'package:commons_core/commons_core.dart';
import 'package:drift/drift.dart';
import '../db/database.dart';
import '../domain/species_autoclassify.dart';
/// One entry from the bundled catalog, before it is stored.
class SpeciesSeed {
const SpeciesSeed({
required this.scientificName,
this.family,
this.wikidataQid,
this.gbifKey,
this.commonNames = const {},
this.viabilityYears,
this.gbifKey,
this.wikidataQid,
});
final String scientificName;
final String? family;
/// Wikidata entity id (e.g. `Q13223`), the CC0 source of this row; null when
/// the catalog was authored by hand. Kept for de-duplication and to feed the
/// derived Wikipedia (locale-aware) reference link.
final String? wikidataQid;
/// GBIF backbone taxon key; null if unknown. Feeds the derived reference link.
final int? gbifKey;
/// language code → list of common names.
final Map<String, List<String>> commonNames;
/// Typical seed longevity in years (bundled reference data); null if unknown.
final int? viabilityYears;
/// GBIF backbone taxon key; null if unknown. Feeds the derived reference link.
final int? gbifKey;
/// Wikidata item id (e.g. `Q23501`); null if unknown. Feeds the derived
/// Wikipedia (locale-aware) reference link.
final String? wikidataQid;
}
/// A catalog match surfaced to the UI (with a best common name for the locale).
@ -60,94 +62,203 @@ class SpeciesRepository {
final String nodeId;
/// Idempotently inserts bundled species (keyed by scientific name). Safe to
/// call on every startup. Existing rows keep their identity, but a bundled
/// row still missing [SpeciesSeed.viabilityYears] is backfilled — so the
/// reference data reaches installs seeded before the field was bundled.
/// call on every startup. Existing rows keep their identity, but bundled
/// reference fields still missing on a row ([SpeciesSeed.viabilityYears],
/// [SpeciesSeed.wikidataQid], [SpeciesSeed.gbifKey]) are backfilled — so data
/// added to the catalog reaches installs seeded before the field was bundled.
///
/// Reads all existing species once and writes in a single batch: with a
/// catalog of ~1000 species a per-row SELECT on every startup would be a real
/// cost on the encrypted database.
Future<void> seedBundled(List<SpeciesSeed> seeds) async {
final stamp = Hlc.zero(nodeId).pack();
await _db.transaction(() async {
final existing = {
for (final s in await _db.select(_db.species).get())
s.scientificName: s,
};
final newSpecies = <SpeciesCompanion>[];
final newNames = <SpeciesCommonNamesCompanion>[];
final backfills = <({String id, SpeciesCompanion patch})>[];
for (final seed in seeds) {
final existing =
await (_db.select(_db.species)
..where((s) => s.scientificName.equals(seed.scientificName)))
.getSingleOrNull();
if (existing != null) {
// Backfill bundled reference data added after the row was seeded, so
// it reaches installs seeded before these fields were bundled. Each
// field is only written when the row still lacks it.
final backfill = SpeciesCompanion(
viabilityYears:
existing.viabilityYears == null && seed.viabilityYears != null
? Value(seed.viabilityYears)
: const Value.absent(),
gbifKey: existing.gbifKey == null && seed.gbifKey != null
? Value(seed.gbifKey)
: const Value.absent(),
wikidataQid:
existing.wikidataQid == null && seed.wikidataQid != null
? Value(seed.wikidataQid)
: const Value.absent(),
);
if (backfill.viabilityYears.present ||
backfill.gbifKey.present ||
backfill.wikidataQid.present) {
await (_db.update(
_db.species,
)..where((s) => s.id.equals(existing.id))).write(backfill);
}
final row = existing[seed.scientificName];
if (row != null) {
final patch = _backfillPatch(row, seed);
if (patch != null) backfills.add((id: row.id, patch: patch));
continue;
}
final speciesId = idGen.newId();
await _db
.into(_db.species)
.insert(
SpeciesCompanion.insert(
id: speciesId,
createdAt: 0,
updatedAt: stamp,
lastAuthor: nodeId,
scientificName: seed.scientificName,
family: Value(seed.family),
isBundled: const Value(true),
viabilityYears: Value(seed.viabilityYears),
gbifKey: Value(seed.gbifKey),
wikidataQid: Value(seed.wikidataQid),
),
);
newSpecies.add(
SpeciesCompanion.insert(
id: speciesId,
createdAt: 0,
updatedAt: stamp,
lastAuthor: nodeId,
scientificName: seed.scientificName,
family: Value(seed.family),
wikidataQid: Value(seed.wikidataQid),
gbifKey: Value(seed.gbifKey),
isBundled: const Value(true),
viabilityYears: Value(seed.viabilityYears),
),
);
for (final entry in seed.commonNames.entries) {
for (final name in entry.value) {
await _db
.into(_db.speciesCommonNames)
.insert(
SpeciesCommonNamesCompanion.insert(
id: idGen.newId(),
createdAt: 0,
updatedAt: stamp,
lastAuthor: nodeId,
speciesId: speciesId,
name: name,
language: Value(entry.key),
),
);
newNames.add(
SpeciesCommonNamesCompanion.insert(
id: idGen.newId(),
createdAt: 0,
updatedAt: stamp,
lastAuthor: nodeId,
speciesId: speciesId,
name: name,
language: Value(entry.key),
),
);
}
}
}
if (newSpecies.isEmpty && newNames.isEmpty && backfills.isEmpty) return;
await _db.batch((b) {
b.insertAll(_db.species, newSpecies);
b.insertAll(_db.speciesCommonNames, newNames);
for (final entry in backfills) {
b.update(
_db.species,
entry.patch,
where: (s) => s.id.equals(entry.id),
);
}
});
});
}
/// A partial update carrying only the bundled reference fields a stored row is
/// still missing, or null when the row is already complete.
SpeciesCompanion? _backfillPatch(Specy row, SpeciesSeed seed) {
var patch = const SpeciesCompanion();
var changed = false;
if (row.viabilityYears == null && seed.viabilityYears != null) {
patch = patch.copyWith(viabilityYears: Value(seed.viabilityYears));
changed = true;
}
if (row.wikidataQid == null && seed.wikidataQid != null) {
patch = patch.copyWith(wikidataQid: Value(seed.wikidataQid));
changed = true;
}
if (row.gbifKey == null && seed.gbifKey != null) {
patch = patch.copyWith(gbifKey: Value(seed.gbifKey));
changed = true;
}
return changed ? patch : null;
}
/// Searches species by scientific name or a common name (case-insensitive
/// substring). The catalog is small, so it is filtered in Dart. Returns up to
/// [limit] matches, each with a best common name for [languageCode].
/// substring). Filtering runs in SQL (`LIKE`) so a large catalog is not pulled
/// into memory on every keystroke. Returns up to [limit] matches, each with a
/// best common name for [languageCode].
Future<List<SpeciesMatch>> search(
String query, {
String languageCode = 'en',
int limit = 8,
}) async {
final q = query.trim().toLowerCase();
final q = query.trim();
if (q.isEmpty) return const [];
// SQLite `LIKE` is case-insensitive for ASCII (matching the previous
// `toLowerCase().contains` behaviour); `%`/`_`/`\` in the query are escaped
// so they match literally rather than acting as wildcards.
final pattern = '%${_escapeLike(q)}%';
// A few extra candidates so the final scientific-name sort/limit is stable.
final scan = limit * 4;
final byScientific =
await (_db.select(_db.species)
..where(
(s) =>
s.isDeleted.equals(false) &
s.scientificName.like(pattern, escapeChar: r'\'),
)
..limit(scan))
.get();
final byCommon =
await (_db.select(_db.speciesCommonNames)
..where(
(n) =>
n.isDeleted.equals(false) &
n.name.like(pattern, escapeChar: r'\'),
)
..limit(scan))
.get();
final speciesById = {for (final s in byScientific) s.id: s};
final missing = byCommon
.map((n) => n.speciesId)
.where((id) => !speciesById.containsKey(id))
.toSet();
if (missing.isNotEmpty) {
final more =
await (_db.select(_db.species)..where(
(s) => s.isDeleted.equals(false) & s.id.isIn(missing.toList()),
))
.get();
for (final s in more) {
speciesById[s.id] = s;
}
}
if (speciesById.isEmpty) return const [];
// Resolve a localized label only for the matched species.
final names =
await (_db.select(_db.speciesCommonNames)..where(
(n) =>
n.isDeleted.equals(false) &
n.speciesId.isIn(speciesById.keys.toList()),
))
.get();
final namesBySpecies = <String, List<({String name, String? language})>>{};
for (final n in names) {
namesBySpecies.putIfAbsent(n.speciesId, () => []).add((
name: n.name,
language: n.language,
));
}
final matches = [
for (final s in speciesById.values)
SpeciesMatch(
id: s.id,
scientificName: s.scientificName,
family: s.family,
commonName: _bestName(namesBySpecies[s.id] ?? const [], languageCode),
),
];
matches.sort((a, b) => a.scientificName.compareTo(b.scientificName));
return matches.take(limit).toList();
}
/// Escapes SQL `LIKE` metacharacters so a user query matches literally.
String _escapeLike(String input) => input
.replaceAll(r'\', r'\\')
.replaceAll('%', r'\%')
.replaceAll('_', r'\_');
/// Auto-classification for the UI: infers the single species a free-text
/// variety [label] names (see [matchSpeciesInLabel]) and returns it as a
/// [SpeciesMatch] with a best common name for [languageCode]. Returns null
/// when the label names no known species or the match is ambiguous — so the
/// caller can offer it as a one-tap suggestion, never a silent guess.
Future<SpeciesMatch?> classifyLabel(
String label, {
String languageCode = 'en',
}) async {
final species = await (_db.select(
_db.species,
)..where((s) => s.isDeleted.equals(false))).get();
@ -155,32 +266,26 @@ class SpeciesRepository {
_db.speciesCommonNames,
)..where((n) => n.isDeleted.equals(false))).get();
final namesBySpecies = <String, List<({String name, String? language})>>{};
for (final c in commons) {
namesBySpecies.putIfAbsent(c.speciesId, () => []).add((
name: c.name,
language: c.language,
));
}
final names = <SpeciesNameEntry>[
for (final s in species)
SpeciesNameEntry(speciesId: s.id, name: s.scientificName),
for (final c in commons)
SpeciesNameEntry(speciesId: c.speciesId, name: c.name),
];
final id = matchSpeciesInLabel(label, names);
if (id == null) return null;
final matches = <SpeciesMatch>[];
for (final s in species) {
final names = namesBySpecies[s.id] ?? const [];
final matchesScientific = s.scientificName.toLowerCase().contains(q);
final matchesCommon = names.any((n) => n.name.toLowerCase().contains(q));
if (matchesScientific || matchesCommon) {
matches.add(
SpeciesMatch(
id: s.id,
scientificName: s.scientificName,
family: s.family,
commonName: _bestName(names, languageCode),
),
);
}
}
matches.sort((a, b) => a.scientificName.compareTo(b.scientificName));
return matches.take(limit).toList();
final match = species.firstWhere((s) => s.id == id);
final matchNames = [
for (final c in commons)
if (c.speciesId == id) (name: c.name, language: c.language),
];
return SpeciesMatch(
id: match.id,
scientificName: match.scientificName,
family: match.family,
commonName: _bestName(matchNames, languageCode),
);
}
String? _bestName(

167
apps/app_seeds/lib/data/variety_repository.dart
View file

@ -6,6 +6,7 @@ import 'package:equatable/equatable.dart';
import '../db/database.dart';
import '../db/enums.dart';
import '../domain/seed_viability.dart';
import '../domain/species_autoclassify.dart';
import 'export_import/import_reconciler.dart';
import 'export_import/inventory_csv_codec.dart';
import 'export_import/inventory_snapshot.dart';
@ -657,6 +658,11 @@ class VarietyRepository {
/// The 20-second quick-add: a [label] (required) plus an optional [category],
/// an optional [quantity] (creates a Lot) and an optional [photoBytes]
/// (stored as an encrypted BLOB Attachment). Returns the new Variety id.
///
/// If the label names a bundled species ("Maíz de la abuela" → *Zea mays*),
/// the variety is linked to it automatically and its category prefilled from
/// the species' family — the grower never has to open the species picker for
/// the common case. An explicit [category] is always kept as given.
Future<String> addQuickVariety({
required String label,
String? category,
@ -665,8 +671,10 @@ class VarietyRepository {
Uint8List? photoBytes,
}) async {
final varietyId = idGen.newId();
final auto = await _autoClassifyFromLabel(label);
final resolvedCategory = _hasText(category) ? category : auto?.family;
await _db.transaction(() async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.varieties)
.insert(
@ -676,12 +684,13 @@ class VarietyRepository {
createdAt: created,
updatedAt: updated,
lastAuthor: nodeId,
category: Value(category),
category: Value(resolvedCategory),
speciesId: Value(auto?.id),
),
);
if (quantity != null) {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.lots)
.insert(
@ -700,7 +709,7 @@ class VarietyRepository {
}
if (photoBytes != null) {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.attachments)
.insert(
@ -727,7 +736,7 @@ class VarietyRepository {
Future<String> addDraftVariety(Uint8List photoBytes) async {
final varietyId = idGen.newId();
await _db.transaction(() async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.varieties)
.insert(
@ -740,7 +749,7 @@ class VarietyRepository {
isDraft: const Value(true),
),
);
final (createdA, updatedA) = _stamp();
final (createdA, updatedA) = await _stamp();
await _db
.into(_db.attachments)
.insert(
@ -762,12 +771,26 @@ class VarietyRepository {
/// Names a draft and promotes it out of the "to catalogue" tray: sets its
/// [label] and clears [isDraft] in one LWW write.
///
/// Like [addQuickVariety], if the new [label] names a bundled species the
/// draft is auto-linked to it and its category prefilled from the family —
/// but only when the draft has neither yet, so it never overrides a species
/// or category the grower already set on the draft.
Future<void> nameDraft(String id, String label) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
final draft = await (_db.select(
_db.varieties,
)..where((v) => v.id.equals(id))).getSingleOrNull();
final auto = draft?.speciesId == null
? await _autoClassifyFromLabel(label)
: null;
final prefillCategory = auto != null && !_hasText(draft?.category);
await (_db.update(_db.varieties)..where((v) => v.id.equals(id))).write(
VarietiesCompanion(
label: Value(label),
isDraft: const Value(false),
speciesId: auto == null ? const Value.absent() : Value(auto.id),
category: prefillCategory ? Value(auto.family) : const Value.absent(),
updatedAt: Value(updated),
lastAuthor: Value(nodeId),
),
@ -949,10 +972,44 @@ class VarietyRepository {
);
}
/// Infers a catalog species from a free-text [label] (see
/// [matchSpeciesInLabel]). Returns the matched species' id and family, or null
/// when the label names no known species or the match is ambiguous.
Future<({String id, String? family})?> _autoClassifyFromLabel(
String label,
) async {
final speciesId = matchSpeciesInLabel(label, await _speciesNamesForMatching());
if (speciesId == null) return null;
final species = await (_db.select(
_db.species,
)..where((s) => s.id.equals(speciesId))).getSingleOrNull();
return species == null ? null : (id: species.id, family: species.family);
}
/// Every catalog name that can identify a species — its scientific name and
/// all non-deleted common names, across every bundled locale — flattened for
/// the language-agnostic matcher. The catalog is small, so this is cheap.
Future<List<SpeciesNameEntry>> _speciesNamesForMatching() async {
final species = await (_db.select(
_db.species,
)..where((s) => s.isDeleted.equals(false))).get();
final commons = await (_db.select(
_db.speciesCommonNames,
)..where((n) => n.isDeleted.equals(false))).get();
return [
for (final s in species)
SpeciesNameEntry(speciesId: s.id, name: s.scientificName),
for (final c in commons)
SpeciesNameEntry(speciesId: c.speciesId, name: c.name),
];
}
bool _hasText(String? value) => value != null && value.trim().isNotEmpty;
/// Links [varietyId] to a catalog [speciesId]. If the variety has no category
/// yet, prefill it from the species' botanical family (data-model §6).
Future<void> linkSpecies(String varietyId, String speciesId) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
final species = await (_db.select(
_db.species,
)..where((s) => s.id.equals(speciesId))).getSingleOrNull();
@ -993,7 +1050,7 @@ class VarietyRepository {
Value<int?> fruitingMonths = const Value.absent(),
Value<int?> seedHarvestMonths = const Value.absent(),
}) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(_db.varieties)..where((v) => v.id.equals(id))).write(
VarietiesCompanion(
label: label == null ? const Value.absent() : Value(label),
@ -1029,7 +1086,7 @@ class VarietyRepository {
PreservationFormat? preservationFormat,
OfferStatus offerStatus = OfferStatus.private,
}) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.lots)
@ -1074,7 +1131,7 @@ class VarietyRepository {
PreservationFormat? preservationFormat,
OfferStatus offerStatus = OfferStatus.private,
}) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(_db.lots)..where((l) => l.id.equals(lotId))).write(
LotsCompanion(
type: Value(type),
@ -1155,7 +1212,7 @@ class VarietyRepository {
/// Soft-deletes a lot (tombstone); it leaves the variety's lot list.
Future<void> softDeleteLot(String lotId) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(_db.lots)..where((l) => l.id.equals(lotId))).write(
LotsCompanion(
isDeleted: const Value(true),
@ -1172,7 +1229,7 @@ class VarietyRepository {
String? language,
String? region,
}) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.varietyVernacularNames)
@ -1193,7 +1250,7 @@ class VarietyRepository {
/// Soft-deletes a vernacular name (tombstone).
Future<void> removeVernacularName(String nameId) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(
_db.varietyVernacularNames,
)..where((n) => n.id.equals(nameId))).write(
@ -1207,7 +1264,7 @@ class VarietyRepository {
/// Adds a photo (encrypted BLOB) to a variety. Returns the new attachment id.
Future<String> addPhoto(String varietyId, Uint8List bytes) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.attachments)
@ -1229,7 +1286,7 @@ class VarietyRepository {
/// Soft-deletes a photo (tombstone).
Future<void> removePhoto(String attachmentId) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(
_db.attachments,
)..where((a) => a.id.equals(attachmentId))).write(
@ -1257,7 +1314,7 @@ class VarietyRepository {
for (final a in siblings) {
if (a.sortOrder < minOrder) minOrder = a.sortOrder;
}
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(
_db.attachments,
)..where((a) => a.id.equals(attachmentId))).write(
@ -1275,7 +1332,7 @@ class VarietyRepository {
String url, {
String? title,
}) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.externalLinks)
@ -1296,7 +1353,7 @@ class VarietyRepository {
/// Soft-deletes an external link (tombstone).
Future<void> removeExternalLink(String linkId) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(
_db.externalLinks,
)..where((e) => e.id.equals(linkId))).write(
@ -1311,7 +1368,7 @@ class VarietyRepository {
/// Soft-deletes a variety (tombstone); it disappears from the inventory but
/// the row survives for correct CRDT merges later.
Future<void> softDeleteVariety(String id) async {
final (_, updated) = _stamp();
final (_, updated) = await _stamp();
await (_db.update(_db.varieties)..where((v) => v.id.equals(id))).write(
VarietiesCompanion(
isDeleted: const Value(true),
@ -1329,7 +1386,7 @@ class VarietyRepository {
int? germinatedCount,
String? notes,
}) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.germinationTests)
@ -1358,7 +1415,7 @@ class VarietyRepository {
DesiccantState? desiccantState,
String? notes,
}) async {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
final id = idGen.newId();
await _db
.into(_db.conditionChecks)
@ -1537,7 +1594,7 @@ class VarietyRepository {
for (final v in csv.varieties) {
final speciesId = await _resolveSpeciesByName(v.scientificName);
final varietyId = idGen.newId();
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.varieties)
.insert(
@ -1562,7 +1619,7 @@ class VarietyRepository {
inserted++;
for (final lot in v.lots) {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.lots)
.insert(
@ -1590,7 +1647,7 @@ class VarietyRepository {
}
for (final name in v.vernacularNames) {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.varietyVernacularNames)
.insert(
@ -1607,7 +1664,7 @@ class VarietyRepository {
}
for (final link in v.links) {
final (created, updated) = _stamp();
final (created, updated) = await _stamp();
await _db
.into(_db.externalLinks)
.insert(
@ -1767,9 +1824,65 @@ class VarietyRepository {
QuantityKind.values.asNameMap()[name] ?? QuantityKind.aFew;
/// Advances the local clock and returns `(createdAtMillis, packedHlc)`.
(int, String) _stamp() {
///
/// Before the first stamp of the session the clock is re-seeded from the
/// newest stamp already stored in the DB (see [_ensureClockSeeded]). The
/// in-memory clock starts fresh at [Hlc.zero] every app launch, so without
/// this a local edit could be stamped *older* than a row written in an
/// earlier session or imported from a peer whose wall clock ran ahead — and
/// silently lose last-writer-wins when the backup is shared back.
Future<(int, String)> _stamp() async {
await _ensureClockSeeded();
final now = _now();
_clock = _clock.localEvent(now);
return (now, _clock.pack());
}
Future<void>? _clockSeeded;
/// Absorbs the newest stored stamp into the local clock exactly once per
/// repository instance, so it never runs behind data the DB already holds.
Future<void> _ensureClockSeeded() =>
_clockSeeded ??= _seedClockFromStoredRows();
Future<void> _seedClockFromStoredRows() async {
final maxStored = await _maxStoredHlc();
if (maxStored != null) {
_clock = _clock.receiveEvent(maxStored, _now());
}
}
/// The newest packed HLC `updatedAt` across every mutable table, or null when
/// the inventory is empty. Packed stamps are fixed-width and
/// lexicographically sortable, so SQL `MAX` orders them exactly like
/// [Hlc.compareTo].
Future<Hlc?> _maxStoredHlc() async {
final tables =
<
(
ResultSetImplementation<HasResultSet, dynamic>,
GeneratedColumn<String>,
)
>[
(_db.varieties, _db.varieties.updatedAt),
(_db.lots, _db.lots.updatedAt),
(_db.varietyVernacularNames, _db.varietyVernacularNames.updatedAt),
(_db.externalLinks, _db.externalLinks.updatedAt),
(_db.germinationTests, _db.germinationTests.updatedAt),
(_db.conditionChecks, _db.conditionChecks.updatedAt),
(_db.parties, _db.parties.updatedAt),
(_db.attachments, _db.attachments.updatedAt),
];
String? maxPacked;
for (final (table, column) in tables) {
final max = column.max();
final query = _db.selectOnly(table)..addColumns([max]);
final packed = (await query.getSingleOrNull())?.read(max);
if (packed != null &&
(maxPacked == null || packed.compareTo(maxPacked) > 0)) {
maxPacked = packed;
}
}
return maxPacked == null ? null : Hlc.parse(maxPacked);
}
}

128
apps/app_seeds/lib/domain/species_autoclassify.dart Normal file
View file

@ -0,0 +1,128 @@
/// Auto-classification: infer the species a free-text variety label refers to,
/// so typing "Maíz de la abuela" can link *Zea mays* (and prefill the category)
/// without the grower opening the species picker.
///
/// Pure domain logic (no DB, no Flutter) so it is trivially unit-testable. The
/// repository feeds it the bundled catalog names; matching is done here.
library;
/// One catalog name that can identify a species: a common (vernacular) name or
/// the scientific name, paired with the species it belongs to. The matcher is
/// language-agnostic — it never assumes es/en — so the repository passes names
/// from every bundled locale at once.
class SpeciesNameEntry {
const SpeciesNameEntry({required this.speciesId, required this.name});
final String speciesId;
final String name;
}
/// Detects the species a free-text variety [label] refers to by matching a
/// bundled [names] entry as a whole word inside the label — accent- and
/// case-insensitively. "Maíz de la abuela" → *Zea mays*; "Tomate cherry" →
/// *Solanum lycopersicum*.
///
/// Returns the matched species id, or null when nothing matches or the best
/// match is ambiguous. The rules keep it from mislabelling:
/// * **Whole-word (token) match only**, so "pea" never fires on "peach" nor
/// "haba" on "habanero" — a common name must appear as its own word(s).
/// * **Longest name wins** (most specific): "broad bean" beats "bean".
/// * **Ambiguous → null**: if the winning name maps to more than one species
/// (e.g. "calabaza" spanning several squashes), it is left for the grower
/// to disambiguate rather than guessed.
///
/// A light trailing-`s` fold lets a plural label word ("Tomates", "Habas")
/// still match a singular catalog name. It is an additive nudge for the many
/// languages that pluralise with `-s`, never an override of an exact match, and
/// it cannot introduce a match that a different word did not already carry.
String? matchSpeciesInLabel(String label, List<SpeciesNameEntry> names) {
final haystack = _tokenize(label);
if (haystack.isEmpty) return null;
({int tokens, int chars})? best;
final winners = <String>{};
for (final entry in names) {
final needle = _tokenize(entry.name);
if (!_containsSequence(haystack, needle)) continue;
final chars = needle.fold<int>(0, (sum, t) => sum + t.length);
final score = (tokens: needle.length, chars: chars);
if (best == null || _isBetter(score, best!)) {
best = score;
winners
..clear()
..add(entry.speciesId);
} else if (score.tokens == best!.tokens && score.chars == best!.chars) {
winners.add(entry.speciesId);
}
}
// A single species behind the best-scoring name(s) → confident; otherwise the
// name is shared across species, so leave it unclassified.
return winners.length == 1 ? winners.first : null;
}
bool _isBetter(({int tokens, int chars}) a, ({int tokens, int chars}) b) =>
a.tokens > b.tokens || (a.tokens == b.tokens && a.chars > b.chars);
/// Lowercases, splits on any non-letter/non-digit boundary (Unicode-aware, so
/// non-Latin scripts survive), and folds Latin diacritics on each token.
List<String> _tokenize(String s) => s
.toLowerCase()
.split(_wordBoundary)
.where((t) => t.isNotEmpty)
.map(_foldDiacritics)
.toList(growable: false);
final RegExp _wordBoundary = RegExp(r'[^\p{L}\p{N}]+', unicode: true);
/// True when [needle] appears as a contiguous run of words inside [haystack].
bool _containsSequence(List<String> haystack, List<String> needle) {
if (needle.isEmpty || needle.length > haystack.length) return false;
for (var i = 0; i + needle.length <= haystack.length; i++) {
var matched = true;
for (var j = 0; j < needle.length; j++) {
if (!_wordsEqual(haystack[i + j], needle[j])) {
matched = false;
break;
}
}
if (matched) return true;
}
return false;
}
bool _wordsEqual(String a, String b) => a == b || _singular(a) == _singular(b);
/// Drops a single trailing `s` from words longer than three letters — a
/// deliberately crude plural fold (see [matchSpeciesInLabel]).
String _singular(String t) =>
(t.length > 3 && t.endsWith('s')) ? t.substring(0, t.length - 1) : t;
/// Folds common Latin diacritics to their base letter so "Maiz" matches "Maíz".
/// Only Latin marks are folded; other scripts pass through untouched, keeping
/// the matcher usable for any language.
String _foldDiacritics(String token) {
if (token.codeUnits.every((c) => c < 0x80)) return token; // fast path: ASCII
final buffer = StringBuffer();
for (final ch in token.split('')) {
buffer.write(_diacriticFolds[ch] ?? ch);
}
return buffer.toString();
}
const Map<String, String> _diacriticFolds = {
'á': 'a', 'à': 'a', 'ä': 'a', 'â': 'a', 'ã': 'a', 'å': 'a', 'ā': 'a',
'ă': 'a', 'ą': 'a',
'é': 'e', 'è': 'e', 'ë': 'e', 'ê': 'e', 'ē': 'e', 'ė': 'e', 'ę': 'e',
'ě': 'e',
'í': 'i', 'ì': 'i', 'ï': 'i', 'î': 'i', 'ī': 'i', 'į': 'i', 'ı': 'i',
'ó': 'o', 'ò': 'o', 'ö': 'o', 'ô': 'o', 'õ': 'o', 'ø': 'o', 'ō': 'o',
'ő': 'o',
'ú': 'u', 'ù': 'u', 'ü': 'u', 'û': 'u', 'ū': 'u', 'ů': 'u', 'ű': 'u',
'ñ': 'n', 'ń': 'n', 'ň': 'n',
'ç': 'c', 'ć': 'c', 'č': 'c',
'ş': 's', 'š': 's', 'ș': 's', 'ś': 's',
'ž': 'z', 'ź': 'z', 'ż': 'z',
'ý': 'y', 'ÿ': 'y',
'ğ': 'g', 'ł': 'l', 'ð': 'd', 'þ': 'th', 'ß': 'ss', 'œ': 'oe', 'æ': 'ae',
};

4
apps/app_seeds/lib/i18n/en.i18n.json
View file

@ -86,7 +86,8 @@
"licenseValue": "AGPL-3.0",
"website": "Website",
"openSourceLicenses": "Open-source licenses",
"openSourceLicensesSubtitle": "Third-party libraries and their licenses"
"openSourceLicensesSubtitle": "Third-party libraries and their licenses",
"copyright": "© {years} Comunes Association, under AGPLv3"
},
"intro": {
"skip": "Skip",
@ -190,6 +191,7 @@
"notes": "Notes",
"species": "Species (from catalog)",
"speciesHint": "Search a species…",
"speciesSuggested": "Suggested from the name",
"organic": "Organic",
"organicHint": "Grown organically (eco)"
},

4
apps/app_seeds/lib/i18n/es.i18n.json
View file

@ -86,7 +86,8 @@
"licenseValue": "AGPL-3.0",
"website": "Sitio web",
"openSourceLicenses": "Licencias de código abierto",
"openSourceLicensesSubtitle": "Bibliotecas de terceros y sus licencias"
"openSourceLicensesSubtitle": "Bibliotecas de terceros y sus licencias",
"copyright": "© {years} Asociación Comunes, bajo AGPLv3"
},
"intro": {
"skip": "Saltar",
@ -190,6 +191,7 @@
"notes": "Notas",
"species": "Especie (del catálogo)",
"speciesHint": "Buscar una especie…",
"speciesSuggested": "Sugerida por el nombre",
"organic": "Ecológica",
"organicHint": "Cultivada de forma ecológica (eco)"
},

4
apps/app_seeds/lib/i18n/pt.i18n.json
View file

@ -86,7 +86,8 @@
"licenseValue": "AGPL-3.0",
"website": "Sítio web",
"openSourceLicenses": "Licenças de código aberto",
"openSourceLicensesSubtitle": "Bibliotecas de terceiros e as suas licenças"
"openSourceLicensesSubtitle": "Bibliotecas de terceiros e as suas licenças",
"copyright": "© {years} Associação Comunes, sob AGPLv3"
},
"intro": {
"skip": "Saltar",
@ -186,6 +187,7 @@
"notes": "Notas",
"species": "Espécie (do catálogo)",
"speciesHint": "Procura uma espécie…",
"speciesSuggested": "Sugerida pelo nome",
"organic": "Biológica",
"organicHint": "Cultivada em modo biológico"
},

181
apps/app_seeds/lib/i18n/strings.g.dart Normal file
View file

@ -0,0 +1,181 @@
/// Generated file. Do not edit.
///
/// Source: lib/i18n
/// To regenerate, run: `dart run slang`
///
/// Locales: 3
/// Strings: 875 (291 per locale)
///
/// Built on 2026-07-10 at 00:35 UTC
// coverage:ignore-file
// ignore_for_file: type=lint, unused_import
// dart format off
import 'package:flutter/widgets.dart';
import 'package:intl/intl.dart';
import 'package:slang/generated.dart';
import 'package:slang_flutter/slang_flutter.dart';
export 'package:slang_flutter/slang_flutter.dart';
import 'strings_es.g.dart' as l_es;
import 'strings_pt.g.dart' as l_pt;
part 'strings_en.g.dart';
/// Supported locales.
///
/// Usage:
/// - LocaleSettings.setLocale(AppLocale.en) // set locale
/// - Locale locale = AppLocale.en.flutterLocale // get flutter locale from enum
/// - if (LocaleSettings.currentLocale == AppLocale.en) // locale check
enum AppLocale with BaseAppLocale<AppLocale, Translations> {
en(languageCode: 'en'),
es(languageCode: 'es'),
pt(languageCode: 'pt');
const AppLocale({
required this.languageCode,
this.scriptCode, // ignore: unused_element, unused_element_parameter
this.countryCode, // ignore: unused_element, unused_element_parameter
});
@override final String languageCode;
@override final String? scriptCode;
@override final String? countryCode;
@override
Future<Translations> build({
Map<String, Node>? overrides,
PluralResolver? cardinalResolver,
PluralResolver? ordinalResolver,
}) async {
return buildSync(
overrides: overrides,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
}
@override
Translations buildSync({
Map<String, Node>? overrides,
PluralResolver? cardinalResolver,
PluralResolver? ordinalResolver,
}) {
switch (this) {
case AppLocale.en:
return TranslationsEn(
overrides: overrides,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
case AppLocale.es:
return l_es.TranslationsEs(
overrides: overrides,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
case AppLocale.pt:
return l_pt.TranslationsPt(
overrides: overrides,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
}
}
/// Gets current instance managed by [LocaleSettings].
Translations get translations => LocaleSettings.instance.getTranslations(this);
}
/// Method A: Simple
///
/// No rebuild after locale change.
/// Translation happens during initialization of the widget (call of t).
/// Configurable via 'translate_var'.
///
/// Usage:
/// String a = t.someKey.anotherKey;
/// String b = t['someKey.anotherKey']; // Only for edge cases!
Translations get t => LocaleSettings.instance.currentTranslations;
/// Method B: Advanced
///
/// All widgets using this method will trigger a rebuild when locale changes.
/// Use this if you have e.g. a settings page where the user can select the locale during runtime.
///
/// Step 1:
/// wrap your App with
/// TranslationProvider(
/// child: MyApp()
/// );
///
/// Step 2:
/// final t = Translations.of(context); // Get t variable.
/// String a = t.someKey.anotherKey; // Use t variable.
/// String b = t['someKey.anotherKey']; // Only for edge cases!
class TranslationProvider extends BaseTranslationProvider<AppLocale, Translations> {
TranslationProvider({required super.child}) : super(settings: LocaleSettings.instance);
static InheritedLocaleData<AppLocale, Translations> of(BuildContext context) => InheritedLocaleData.of<AppLocale, Translations>(context);
}
/// Method B shorthand via [BuildContext] extension method.
/// Configurable via 'translate_var'.
///
/// Usage (e.g. in a widget's build method):
/// context.t.someKey.anotherKey
extension BuildContextTranslationsExtension on BuildContext {
Translations get t => TranslationProvider.of(this).translations;
}
/// Manages all translation instances and the current locale
class LocaleSettings extends BaseFlutterLocaleSettings<AppLocale, Translations> {
LocaleSettings._() : super(
utils: AppLocaleUtils.instance,
lazy: false,
);
static final instance = LocaleSettings._();
// static aliases (checkout base methods for documentation)
static AppLocale get currentLocale => instance.currentLocale;
static Stream<AppLocale> getLocaleStream() => instance.getLocaleStream();
static Future<AppLocale> setLocale(AppLocale locale, {bool? listenToDeviceLocale = false}) => instance.setLocale(locale, listenToDeviceLocale: listenToDeviceLocale);
static Future<AppLocale> setLocaleRaw(String rawLocale, {bool? listenToDeviceLocale = false}) => instance.setLocaleRaw(rawLocale, listenToDeviceLocale: listenToDeviceLocale);
static Future<AppLocale> useDeviceLocale() => instance.useDeviceLocale();
static Future<void> setPluralResolver({String? language, AppLocale? locale, PluralResolver? cardinalResolver, PluralResolver? ordinalResolver}) => instance.setPluralResolver(
language: language,
locale: locale,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
// synchronous versions
static AppLocale setLocaleSync(AppLocale locale, {bool? listenToDeviceLocale = false}) => instance.setLocaleSync(locale, listenToDeviceLocale: listenToDeviceLocale);
static AppLocale setLocaleRawSync(String rawLocale, {bool? listenToDeviceLocale = false}) => instance.setLocaleRawSync(rawLocale, listenToDeviceLocale: listenToDeviceLocale);
static AppLocale useDeviceLocaleSync() => instance.useDeviceLocaleSync();
static void setPluralResolverSync({String? language, AppLocale? locale, PluralResolver? cardinalResolver, PluralResolver? ordinalResolver}) => instance.setPluralResolverSync(
language: language,
locale: locale,
cardinalResolver: cardinalResolver,
ordinalResolver: ordinalResolver,
);
}
/// Provides utility functions without any side effects.
class AppLocaleUtils extends BaseAppLocaleUtils<AppLocale, Translations> {
AppLocaleUtils._() : super(
baseLocale: AppLocale.en,
locales: AppLocale.values,
);
static final instance = AppLocaleUtils._();
// static aliases (checkout base methods for documentation)
static AppLocale parse(String rawLocale) => instance.parse(rawLocale);
static AppLocale parseLocaleParts({required String languageCode, String? scriptCode, String? countryCode}) => instance.parseLocaleParts(languageCode: languageCode, scriptCode: scriptCode, countryCode: countryCode);
static AppLocale findDeviceLocale() => instance.findDeviceLocale();
static List<Locale> get supportedLocales => instance.supportedLocales;
static List<String> get supportedLocalesRaw => instance.supportedLocalesRaw;
}

8
apps/app_seeds/lib/i18n/strings_en.g.dart
View file

@ -360,6 +360,9 @@ class Translations$about$en {
/// en: 'Third-party libraries and their licenses'
String get openSourceLicensesSubtitle => 'Third-party libraries and their licenses';
/// en: '© {years} Comunes Association, under AGPLv3'
String copyright({required Object years}) => '© ${years} Comunes Association, under AGPLv3';
}
// Path: intro
@ -630,6 +633,9 @@ class Translations$editVariety$en {
/// en: 'Search a species…'
String get speciesHint => 'Search a species…';
/// en: 'Suggested from the name'
String get speciesSuggested => 'Suggested from the name';
/// en: 'Organic'
String get organic => 'Organic';
@ -1567,6 +1573,7 @@ extension on Translations {
'about.website' => 'Website',
'about.openSourceLicenses' => 'Open-source licenses',
'about.openSourceLicensesSubtitle' => 'Third-party libraries and their licenses',
'about.copyright' => ({required Object years}) => '© ${years} Comunes Association, under AGPLv3',
'intro.skip' => 'Skip',
'intro.next' => 'Next',
'intro.start' => 'Get started',
@ -1642,6 +1649,7 @@ extension on Translations {
'editVariety.notes' => 'Notes',
'editVariety.species' => 'Species (from catalog)',
'editVariety.speciesHint' => 'Search a species…',
'editVariety.speciesSuggested' => 'Suggested from the name',
'editVariety.organic' => 'Organic',
'editVariety.organicHint' => 'Grown organically (eco)',
'addLot.title' => 'Add lot',

4
apps/app_seeds/lib/i18n/strings_es.g.dart
View file

@ -213,6 +213,7 @@ class _Translations$about$es extends Translations$about$en {
@override String get website => 'Sitio web';
@override String get openSourceLicenses => 'Licencias de código abierto';
@override String get openSourceLicensesSubtitle => 'Bibliotecas de terceros y sus licencias';
@override String copyright({required Object years}) => '© ${years} Asociación Comunes, bajo AGPLv3';
}
// Path: intro
@ -351,6 +352,7 @@ class _Translations$editVariety$es extends Translations$editVariety$en {
@override String get notes => 'Notas';
@override String get species => 'Especie (del catálogo)';
@override String get speciesHint => 'Buscar una especie…';
@override String get speciesSuggested => 'Sugerida por el nombre';
@override String get organic => 'Ecológica';
@override String get organicHint => 'Cultivada de forma ecológica (eco)';
}
@ -1005,6 +1007,7 @@ extension on TranslationsEs {
'about.website' => 'Sitio web',
'about.openSourceLicenses' => 'Licencias de código abierto',
'about.openSourceLicensesSubtitle' => 'Bibliotecas de terceros y sus licencias',
'about.copyright' => ({required Object years}) => '© ${years} Asociación Comunes, bajo AGPLv3',
'intro.skip' => 'Saltar',
'intro.next' => 'Siguiente',
'intro.start' => 'Empezar',
@ -1080,6 +1083,7 @@ extension on TranslationsEs {
'editVariety.notes' => 'Notas',
'editVariety.species' => 'Especie (del catálogo)',
'editVariety.speciesHint' => 'Buscar una especie…',
'editVariety.speciesSuggested' => 'Sugerida por el nombre',
'editVariety.organic' => 'Ecológica',
'editVariety.organicHint' => 'Cultivada de forma ecológica (eco)',
'addLot.title' => 'Añadir lote',

4
apps/app_seeds/lib/i18n/strings_pt.g.dart
View file

@ -213,6 +213,7 @@ class _Translations$about$pt extends Translations$about$en {
@override String get website => 'Sítio web';
@override String get openSourceLicenses => 'Licenças de código aberto';
@override String get openSourceLicensesSubtitle => 'Bibliotecas de terceiros e as suas licenças';
@override String copyright({required Object years}) => '© ${years} Associação Comunes, sob AGPLv3';
}
// Path: intro
@ -347,6 +348,7 @@ class _Translations$editVariety$pt extends Translations$editVariety$en {
@override String get notes => 'Notas';
@override String get species => 'Espécie (do catálogo)';
@override String get speciesHint => 'Procura uma espécie…';
@override String get speciesSuggested => 'Sugerida pelo nome';
@override String get organic => 'Biológica';
@override String get organicHint => 'Cultivada em modo biológico';
}
@ -1001,6 +1003,7 @@ extension on TranslationsPt {
'about.website' => 'Sítio web',
'about.openSourceLicenses' => 'Licenças de código aberto',
'about.openSourceLicensesSubtitle' => 'Bibliotecas de terceiros e as suas licenças',
'about.copyright' => ({required Object years}) => '© ${years} Associação Comunes, sob AGPLv3',
'intro.skip' => 'Saltar',
'intro.next' => 'Seguinte',
'intro.start' => 'Começar',
@ -1072,6 +1075,7 @@ extension on TranslationsPt {
'editVariety.notes' => 'Notas',
'editVariety.species' => 'Espécie (do catálogo)',
'editVariety.speciesHint' => 'Procura uma espécie…',
'editVariety.speciesSuggested' => 'Sugerida pelo nome',
'editVariety.organic' => 'Biológica',
'editVariety.organicHint' => 'Cultivada em modo biológico',
'addLot.title' => 'Adicionar lote',

25
apps/app_seeds/lib/ui/about_screen.dart
View file

@ -8,6 +8,19 @@ import 'theme.dart';
/// The app's public website. Shown as a tappable row in [AboutScreen].
const String _websiteUrl = 'https://tanemaki.app';
/// The year Tanemaki's copyright starts. Ğ1nkgo uses its own first year (2023);
/// Tanemaki's is 2026.
const int _copyrightStartYear = 2026;
/// A single year (`2026`) until the calendar rolls over, then a range
/// (`2026-2027`), mirroring Ğ1nkgo's legalese line.
String _copyrightYears() {
final int now = DateTime.now().year;
return now <= _copyrightStartYear
? '$_copyrightStartYear'
: '$_copyrightStartYear-$now';
}
/// An "about" screen à la Ğ1nkgo: brand header, the human explanation of what
/// Tanemaki is and where its name comes from, the app version, license, the
/// website, and the bundled open-source licenses page.
@ -62,12 +75,24 @@ class AboutScreen extends StatelessWidget {
onTap: () => showLicensePage(
context: context,
applicationName: t.app.title,
applicationLegalese: t.about.copyright(years: _copyrightYears()),
applicationIcon: Padding(
padding: const EdgeInsets.all(8),
child: Image.asset('assets/logo.png', width: 48),
),
),
),
const Divider(height: 32),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20),
child: Text(
t.about.copyright(years: _copyrightYears()),
textAlign: TextAlign.center,
style: Theme.of(context).textTheme.bodySmall?.copyWith(
color: seedOnSurface.withValues(alpha: 0.7),
),
),
),
],
),
);

348
apps/app_seeds/lib/ui/variety_detail_screen.dart
View file

@ -1,3 +1,4 @@
import 'dart:async';
import 'dart:typed_data';
import 'package:drift/drift.dart' show Value;
@ -605,6 +606,11 @@ class _EditVarietySheetState extends State<_EditVarietySheet> {
List<SpeciesMatch> _suggestions = const [];
String? _pickedSpeciesId;
/// A species inferred from the typed name, offered as a one-tap suggestion.
/// Only surfaced while the variety has no species and the grower has not
/// picked one, so it never nags over a deliberate choice.
SpeciesMatch? _suggested;
late bool _isOrganic = widget.detail.isOrganic;
late bool _needsReproduction = widget.detail.needsReproduction;
late int? _sowMonths = widget.detail.sowMonths;
@ -614,8 +620,20 @@ class _EditVarietySheetState extends State<_EditVarietySheet> {
late int? _seedHarvestMonths = widget.detail.seedHarvestMonths;
late bool _calendarOpen = widget.detail.hasCropCalendar;
// Typing stays responsive by not touching the DB on every keystroke: each
// field waits until the grower pauses before running its (heavy) lookup, and
// a per-field query counter drops any result that a later keystroke has
// already superseded, so stale suggestions never flicker back in.
static const _debounce = Duration(milliseconds: 250);
Timer? _speciesDebounce;
Timer? _nameDebounce;
int _speciesQueryId = 0;
int _nameQueryId = 0;
@override
void dispose() {
_speciesDebounce?.cancel();
_nameDebounce?.cancel();
_name.dispose();
_category.dispose();
_notes.dispose();
@ -623,10 +641,38 @@ class _EditVarietySheetState extends State<_EditVarietySheet> {
super.dispose();
}
Future<void> _onSpeciesQuery(String query) async {
void _onSpeciesQuery(String query) {
_speciesDebounce?.cancel();
_speciesDebounce = Timer(_debounce, () => _runSpeciesQuery(query));
}
Future<void> _runSpeciesQuery(String query) async {
final queryId = ++_speciesQueryId;
final lang = Localizations.localeOf(context).languageCode;
final results = await widget.species.search(query, languageCode: lang);
if (mounted) setState(() => _suggestions = results);
// A manual species search takes over from the name-based suggestion.
if (mounted && queryId == _speciesQueryId) {
setState(() => _suggestions = results);
}
}
void _onNameChanged(String name) {
if (widget.detail.speciesId != null || _pickedSpeciesId != null) return;
_nameDebounce?.cancel();
_nameDebounce = Timer(_debounce, () => _runNameClassify(name));
}
/// As the name is typed, offer the species it names — but only when the
/// variety has no species yet and the grower hasn't picked one, so an
/// existing link is never second-guessed.
Future<void> _runNameClassify(String name) async {
if (widget.detail.speciesId != null || _pickedSpeciesId != null) return;
final queryId = ++_nameQueryId;
final lang = Localizations.localeOf(context).languageCode;
final match = await widget.species.classifyLabel(name, languageCode: lang);
if (mounted && queryId == _nameQueryId) {
setState(() => _suggested = match);
}
}
void _pick(SpeciesMatch match) {
@ -634,6 +680,7 @@ class _EditVarietySheetState extends State<_EditVarietySheet> {
_pickedSpeciesId = match.id;
_speciesField.text = match.displayLabel;
_suggestions = const [];
_suggested = null;
});
}
@ -667,145 +714,172 @@ class _EditVarietySheetState extends State<_EditVarietySheet> {
top: 16,
bottom: MediaQuery.of(context).viewInsets.bottom + 16,
),
child: SingleChildScrollView(
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(
t.editVariety.title,
style: Theme.of(context).textTheme.titleLarge,
),
const SizedBox(height: 12),
TextField(
key: const Key('editVariety.name'),
controller: _name,
textCapitalization: TextCapitalization.sentences,
decoration: InputDecoration(
labelText: t.editVariety.name,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
// Fields scroll; the Cancel/Save row is pinned as a fixed footer so Save
// stays visible and tappable no matter how tall the sheet grows.
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Flexible(
child: SingleChildScrollView(
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(
t.editVariety.title,
style: Theme.of(context).textTheme.titleLarge,
),
const SizedBox(height: 12),
TextField(
key: const Key('editVariety.name'),
controller: _name,
textCapitalization: TextCapitalization.sentences,
decoration: InputDecoration(
labelText: t.editVariety.name,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
onChanged: _onNameChanged,
),
const SizedBox(height: 12),
TextField(
key: const Key('editVariety.species'),
controller: _speciesField,
decoration: InputDecoration(
labelText: t.editVariety.species,
hintText: t.editVariety.speciesHint,
prefixIcon: const Icon(Icons.eco_outlined),
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
onChanged: _onSpeciesQuery,
),
for (final match in _suggestions)
ListTile(
dense: true,
key: Key('species.option.${match.id}'),
title: Text(match.displayLabel),
subtitle: match.family == null
? null
: Text(match.family!),
onTap: () => _pick(match),
),
// One-tap suggestion inferred from the name (only when the
// species field is idle, so it never competes with a manual
// search).
if (_suggested case final suggested?
when _suggestions.isEmpty && _pickedSpeciesId == null)
ListTile(
dense: true,
key: const Key('editVariety.speciesSuggestion'),
leading: const Icon(Icons.auto_awesome_outlined),
title: Text(suggested.displayLabel),
subtitle: Text(t.editVariety.speciesSuggested),
onTap: () => _pick(suggested),
),
const SizedBox(height: 12),
TextField(
controller: _category,
textCapitalization: TextCapitalization.sentences,
decoration: InputDecoration(
labelText: t.editVariety.category,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
),
const SizedBox(height: 12),
TextField(
controller: _notes,
minLines: 2,
maxLines: 5,
decoration: InputDecoration(
labelText: t.editVariety.notes,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
),
const SizedBox(height: 4),
SwitchListTile(
key: const Key('editVariety.organic'),
contentPadding: EdgeInsets.zero,
secondary: const Icon(Icons.eco_outlined, color: seedGreen),
title: Text(t.editVariety.organic),
subtitle: Text(t.editVariety.organicHint),
value: _isOrganic,
onChanged: (v) => setState(() => _isOrganic = v),
),
SwitchListTile(
key: const Key('editVariety.needsReproduction'),
contentPadding: EdgeInsets.zero,
secondary: const Icon(Icons.autorenew, color: seedGreen),
title: Text(t.needsReproduction.label),
subtitle: Text(t.needsReproduction.hint),
value: _needsReproduction,
onChanged: (v) => setState(() => _needsReproduction = v),
),
// Crop calendar: one collapsed reveal, not five dropdowns up front.
ExpansionTile(
key: const Key('editVariety.cropCalendar'),
initiallyExpanded: _calendarOpen,
tilePadding: EdgeInsets.zero,
childrenPadding: const EdgeInsets.only(bottom: 8),
leading: const Icon(Icons.calendar_month_outlined),
title: Text(t.cropCalendar.title),
onExpansionChanged: (v) => _calendarOpen = v,
children: [
_MonthMultiSelect(
label: t.cropCalendar.sow,
mask: _sowMonths,
onChanged: (m) => setState(() => _sowMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.transplant,
mask: _transplantMonths,
onChanged: (m) => setState(() => _transplantMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.flowering,
mask: _floweringMonths,
onChanged: (m) => setState(() => _floweringMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.fruiting,
mask: _fruitingMonths,
onChanged: (m) => setState(() => _fruitingMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.seedHarvest,
mask: _seedHarvestMonths,
onChanged: (m) =>
setState(() => _seedHarvestMonths = m),
),
],
),
],
),
),
const SizedBox(height: 12),
TextField(
key: const Key('editVariety.species'),
controller: _speciesField,
decoration: InputDecoration(
labelText: t.editVariety.species,
hintText: t.editVariety.speciesHint,
prefixIcon: const Icon(Icons.eco_outlined),
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
const SizedBox(height: 16),
Row(
children: [
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: Text(t.common.cancel),
),
onChanged: _onSpeciesQuery,
),
for (final match in _suggestions)
ListTile(
dense: true,
key: Key('species.option.${match.id}'),
title: Text(match.displayLabel),
subtitle: match.family == null ? null : Text(match.family!),
onTap: () => _pick(match),
const Spacer(),
FilledButton(
key: const Key('editVariety.save'),
onPressed: _save,
child: Text(t.common.save),
),
const SizedBox(height: 12),
TextField(
controller: _category,
textCapitalization: TextCapitalization.sentences,
decoration: InputDecoration(
labelText: t.editVariety.category,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
),
const SizedBox(height: 12),
TextField(
controller: _notes,
minLines: 2,
maxLines: 5,
decoration: InputDecoration(
labelText: t.editVariety.notes,
border: const OutlineInputBorder(
borderRadius: BorderRadius.all(Radius.circular(8)),
),
),
),
const SizedBox(height: 4),
SwitchListTile(
key: const Key('editVariety.organic'),
contentPadding: EdgeInsets.zero,
secondary: const Icon(Icons.eco_outlined, color: seedGreen),
title: Text(t.editVariety.organic),
subtitle: Text(t.editVariety.organicHint),
value: _isOrganic,
onChanged: (v) => setState(() => _isOrganic = v),
),
SwitchListTile(
key: const Key('editVariety.needsReproduction'),
contentPadding: EdgeInsets.zero,
secondary: const Icon(Icons.autorenew, color: seedGreen),
title: Text(t.needsReproduction.label),
subtitle: Text(t.needsReproduction.hint),
value: _needsReproduction,
onChanged: (v) => setState(() => _needsReproduction = v),
),
// Crop calendar: one collapsed reveal, not five dropdowns up front.
ExpansionTile(
key: const Key('editVariety.cropCalendar'),
initiallyExpanded: _calendarOpen,
tilePadding: EdgeInsets.zero,
childrenPadding: const EdgeInsets.only(bottom: 8),
leading: const Icon(Icons.calendar_month_outlined),
title: Text(t.cropCalendar.title),
onExpansionChanged: (v) => _calendarOpen = v,
children: [
_MonthMultiSelect(
label: t.cropCalendar.sow,
mask: _sowMonths,
onChanged: (m) => setState(() => _sowMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.transplant,
mask: _transplantMonths,
onChanged: (m) => setState(() => _transplantMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.flowering,
mask: _floweringMonths,
onChanged: (m) => setState(() => _floweringMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.fruiting,
mask: _fruitingMonths,
onChanged: (m) => setState(() => _fruitingMonths = m),
),
_MonthMultiSelect(
label: t.cropCalendar.seedHarvest,
mask: _seedHarvestMonths,
onChanged: (m) => setState(() => _seedHarvestMonths = m),
),
],
),
const SizedBox(height: 16),
Row(
children: [
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: Text(t.common.cancel),
),
const Spacer(),
FilledButton(
key: const Key('editVariety.save'),
onPressed: _save,
child: Text(t.common.save),
),
],
),
],
),
],
),
],
),
);
}

87
apps/app_seeds/test/data/export_import/inventory_round_trip_test.dart
View file

@ -210,6 +210,37 @@ void main() {
expect(variety.lastAuthor, 'node-other');
});
test('import overwrites a lot edited elsewhere (LWW)', () async {
final ids = await populate();
// Fork: a second device imports this inventory, edits the lot…
final json = codec.encode(await source.exportInventory());
final otherDb = newTestDatabase();
addTearDown(otherDb.close);
final other = newTestRepository(otherDb, nodeId: 'node-other');
await other.importInventory(codec.decode(json));
await other.updateLot(
lotId: ids.lotId,
type: LotType.seed,
harvestYear: 2025,
quantity: const Quantity(kind: QuantityKind.cob, count: 9),
storageLocation: 'cellar',
);
// …and its export comes back: the newer edit wins here.
final back = codec.encode(await other.exportInventory());
final summary = await source.importInventory(codec.decode(back));
expect(summary.updated, greaterThan(0));
final lot = await (sourceDb.select(
sourceDb.lots,
)..where((l) => l.id.equals(ids.lotId))).getSingle();
expect(lot.harvestYear, 2025);
expect(lot.quantityPrecise, 9);
expect(lot.storageLocation, 'cellar');
expect(lot.lastAuthor, 'node-other');
});
test('after an import the local clock never stamps behind it', () async {
await populate();
final json = codec.encode(await source.exportInventory());
@ -236,6 +267,54 @@ void main() {
expect(Hlc.parse(written.updatedAt).compareTo(maxImported), greaterThan(0));
});
test('a restarted repository re-seeds its clock from stored rows so local '
'edits still win LWW (survives a lagging wall clock)', () async {
// A peer device whose wall clock runs far ahead writes the inventory.
final peerDb = newTestDatabase();
addTearDown(peerDb.close);
final peer = VarietyRepository(
peerDb,
idGen: IdGen(),
nodeId: 'peer',
nowMillis: () => 9000000000000, // ~year 2255
);
final varietyId = await peer.addQuickVariety(label: 'Maize');
final lotId = await peer.addLot(varietyId: varietyId, harvestYear: 2024);
final json = codec.encode(await peer.exportInventory());
// Our device (wall clock in the real, much earlier present) imports it.
final myDb = newTestDatabase();
addTearDown(myDb.close);
const myWall = 1000; // far behind the imported stamps
final importing = VarietyRepository(
myDb,
idGen: IdGen(),
nodeId: 'mine',
nowMillis: () => myWall,
);
await importing.importInventory(codec.decode(json));
// App restart: a brand-new repository instance over the same DB, whose
// in-memory clock starts fresh at Hlc.zero and whose wall clock lags.
final restarted = VarietyRepository(
myDb,
idGen: IdGen(),
nodeId: 'mine',
nowMillis: () => myWall,
);
final before = await _lotStamp(myDb, lotId);
await restarted.updateLot(
lotId: lotId,
type: LotType.seed,
harvestYear: 2030,
);
final after = await _lotStamp(myDb, lotId);
// The edit must out-stamp the imported row, or it would silently lose
// last-writer-wins when this device shares its backup back.
expect(Hlc.parse(after).compareTo(Hlc.parse(before)), greaterThan(0));
});
test('unmatched species leaves speciesId null instead of dangling', () async {
await populate();
final json = codec.encode(await source.exportInventory());
@ -250,3 +329,11 @@ void main() {
expect(variety.speciesId, isNull);
});
}
/// The packed HLC `updatedAt` currently stored for [lotId].
Future<String> _lotStamp(AppDatabase db, String lotId) async {
final lot = await (db.select(
db.lots,
)..where((l) => l.id.equals(lotId))).getSingle();
return lot.updatedAt;
}

84
apps/app_seeds/test/data/species_catalog_asset_test.dart Normal file
View file

@ -0,0 +1,84 @@
import 'dart:convert';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:tane/data/species_catalog.dart';
/// Guards the committed, generated catalog asset (produced by
/// `tool/gen_species_catalog.dart`). Reads the file directly — no Flutter asset
/// bundle needed — so it runs as a plain VM test.
void main() {
// `flutter test` runs with the package root as the working directory.
final file = File('assets/catalog/species.json');
final json = jsonDecode(file.readAsStringSync()) as Map<String, dynamic>;
final species = (json['species'] as List).cast<Map<String, dynamic>>();
test('is the current (version 3) generated catalog', () {
expect(json['version'], 3);
});
test('is a broad catalog, not the old starter set', () {
// The expanded catalog holds ~1200 species (was 14 by hand). The floor
// leaves headroom for Wikidata drift across regenerations.
expect(species.length, greaterThan(900));
});
test('every entry has a scientific name and at least one localized name', () {
for (final e in species) {
final sci = e['scientific_name'];
expect(sci, isA<String>());
expect((sci as String).trim(), isNotEmpty);
final common = e['common'] as Map<String, dynamic>;
expect(common, isNotEmpty, reason: '$sci has no common names');
for (final entry in common.entries) {
final names = (entry.value as List).cast<String>();
expect(names, isNotEmpty);
expect(names.every((n) => n.trim().isNotEmpty), isTrue);
}
}
});
test('identifiers and reference fields are well typed', () {
for (final e in species) {
expect(e['wikidata_qid'], matches(r'^Q\d+$'));
if (e.containsKey('gbif_key')) expect(e['gbif_key'], isA<int>());
if (e.containsKey('viability_years')) {
expect(e['viability_years'], isA<int>());
}
}
});
test('scientific names are unique', () {
final names = species.map((e) => e['scientific_name'] as String).toList();
expect(names.length, names.toSet().length);
});
test('is genuinely multilingual (non-Latin scripts present)', () {
int withLang(String code) =>
species.where((e) => (e['common'] as Map).containsKey(code)).length;
// International by design: Arabic (RTL) and CJK must be represented, not
// an es/en-only catalog.
expect(withLang('ar'), greaterThan(0), reason: 'no Arabic names');
expect(withLang('zh'), greaterThan(0), reason: 'no Chinese names');
expect(withLang('ja'), greaterThan(0), reason: 'no Japanese names');
});
test('keeps the curated core crops with their authoritative names', () {
final byName = {for (final e in species) e['scientific_name'] as String: e};
final tomato = byName['Solanum lycopersicum'];
final carrot = byName['Daucus carota'];
expect(tomato, isNotNull);
expect(carrot, isNotNull);
// Curated names lead (not Wikidata's messier taxon labels) and viability
// reference data survives the regeneration.
expect((tomato!['common'] as Map)['es'], contains('Tomate'));
expect((carrot!['common'] as Map)['es'], contains('Zanahoria'));
expect(carrot['viability_years'], 3);
});
test('parses through the app loader without error', () {
final seeds = parseSpeciesCatalog(file.readAsStringSync());
expect(seeds.length, species.length);
});
}

101
apps/app_seeds/test/data/species_repository_test.dart
View file

@ -40,12 +40,14 @@ void main() {
'parseSpeciesCatalog reads scientific name, family and common names',
() {
const json = '''
{"version":1,"species":[
{"scientific_name":"Zea mays","family":"Poaceae","common":{"en":["Maize"],"es":["Maíz"]}}
{"version":3,"species":[
{"scientific_name":"Zea mays","family":"Poaceae","wikidata_qid":"Q11575","gbif_key":2703077,"common":{"en":["Maize"],"es":["Maíz"]}}
]}''';
final seeds = parseSpeciesCatalog(json);
expect(seeds.single.scientificName, 'Zea mays');
expect(seeds.single.family, 'Poaceae');
expect(seeds.single.wikidataQid, 'Q11575');
expect(seeds.single.gbifKey, 2703077);
expect(seeds.single.commonNames['es'], ['Maíz']);
},
);
@ -140,4 +142,99 @@ void main() {
await repo.seedBundled(_seeds);
expect(await repo.search(' '), isEmpty);
});
test('seedBundled stores wikidata id and gbif key', () async {
await repo.seedBundled(const [
SpeciesSeed(
scientificName: 'Solanum lycopersicum',
family: 'Solanaceae',
wikidataQid: 'Q13223',
gbifKey: 2930137,
commonNames: {
'en': ['Tomato'],
},
),
]);
final row = await db.select(db.species).getSingle();
expect(row.wikidataQid, 'Q13223');
expect(row.gbifKey, 2930137);
});
test('seedBundled backfills reference fields added later', () async {
// First seed lacks the enrichment fields (an older catalog).
await repo.seedBundled(const [
SpeciesSeed(
scientificName: 'Allium cepa',
commonNames: {
'en': ['Onion'],
},
),
]);
// A later catalog carries them; identity is preserved, fields are filled.
await repo.seedBundled(const [
SpeciesSeed(
scientificName: 'Allium cepa',
wikidataQid: 'Q23485',
gbifKey: 2857697,
viabilityYears: 1,
commonNames: {
'en': ['Onion'],
},
),
]);
final rows = await db.select(db.species).get();
expect(rows.length, 1);
expect(rows.single.wikidataQid, 'Q23485');
expect(rows.single.gbifKey, 2857697);
expect(rows.single.viabilityYears, 1);
});
test('search matches a non-Latin common name', () async {
await repo.seedBundled(const [
SpeciesSeed(
scientificName: 'Solanum lycopersicum',
commonNames: {
'ar': ['طماطم'],
'zh': ['番茄'],
},
),
]);
final ar = await repo.search('طماطم', languageCode: 'ar');
expect(ar.single.scientificName, 'Solanum lycopersicum');
expect(ar.single.commonName, 'طماطم');
final zh = await repo.search('番茄', languageCode: 'zh');
expect(zh.single.commonName, '番茄');
});
test('search respects the limit', () async {
final many = [
for (var i = 0; i < 20; i++)
SpeciesSeed(
scientificName: 'Genus species$i',
commonNames: const {
'en': ['Plant'],
},
),
];
await repo.seedBundled(many);
final results = await repo.search('Genus', limit: 5);
expect(results.length, 5);
});
test('classifyLabel infers the species named in a free-text label', () async {
await repo.seedBundled(_seeds);
final match = await repo.classifyLabel('Tomate cherry', languageCode: 'es');
expect(match, isNotNull);
expect(match!.scientificName, 'Solanum lycopersicum');
expect(match.family, 'Solanaceae');
expect(match.commonName, 'Tomate'); // best name for the locale
// No species named → no suggestion.
expect(await repo.classifyLabel('Girasol gigante'), isNull);
});
}

107
apps/app_seeds/test/data/variety_autoclassify_test.dart Normal file
View file

@ -0,0 +1,107 @@
import 'dart:typed_data';
import 'package:commons_core/commons_core.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:tane/data/species_repository.dart';
import 'package:tane/data/variety_repository.dart';
import 'package:tane/db/database.dart';
import '../support/test_support.dart';
/// A starter catalog, including a name ("Calabaza") shared across two species
/// so the ambiguous case can be exercised end-to-end.
const _seeds = [
SpeciesSeed(
scientificName: 'Zea mays',
family: 'Poaceae',
commonNames: {
'es': ['Maíz'],
'en': ['Maize', 'Corn'],
},
),
SpeciesSeed(
scientificName: 'Solanum lycopersicum',
family: 'Solanaceae',
commonNames: {
'es': ['Tomate'],
'en': ['Tomato'],
},
),
SpeciesSeed(
scientificName: 'Cucurbita pepo',
family: 'Cucurbitaceae',
commonNames: {
'es': ['Calabaza', 'Calabacín'],
},
),
SpeciesSeed(
scientificName: 'Cucurbita maxima',
family: 'Cucurbitaceae',
commonNames: {
'es': ['Calabaza'],
},
),
];
void main() {
late AppDatabase db;
late VarietyRepository repo;
setUp(() async {
db = newTestDatabase();
repo = newTestRepository(db);
await SpeciesRepository(db, idGen: IdGen()).seedBundled(_seeds);
});
tearDown(() => db.close());
Future<Variety> only() async => db.select(db.varieties).getSingle();
test('addQuickVariety auto-links the species named in the label', () async {
await repo.addQuickVariety(label: 'Maíz de la abuela');
final v = await only();
final species = await (db.select(
db.species,
)..where((s) => s.id.equals(v.speciesId!))).getSingle();
expect(species.scientificName, 'Zea mays');
// Category is prefilled from the species family.
expect(v.category, 'Poaceae');
});
test('auto-classification is accent-insensitive', () async {
await repo.addQuickVariety(label: 'Maiz dulce'); // typed without the accent
final v = await only();
expect(v.speciesId, isNotNull);
expect(v.category, 'Poaceae');
});
test('an explicit category is kept, species still links', () async {
await repo.addQuickVariety(label: 'Tomate cherry', category: 'Mi huerto');
final v = await only();
expect(v.speciesId, isNotNull);
expect(v.category, 'Mi huerto'); // not overwritten by the family
});
test('an unknown label leaves the variety unclassified', () async {
await repo.addQuickVariety(label: 'Girasol gigante');
final v = await only();
expect(v.speciesId, isNull);
expect(v.category, isNull);
});
test('an ambiguous name is left for the grower to disambiguate', () async {
await repo.addQuickVariety(label: 'Calabaza de invierno');
final v = await only();
expect(v.speciesId, isNull);
expect(v.category, isNull);
});
test('nameDraft auto-classifies when the draft has no species yet', () async {
final id = await repo.addDraftVariety(Uint8List.fromList([1, 2, 3]));
await repo.nameDraft(id, 'Tomate rosa');
final v = await only();
expect(v.isDraft, isFalse);
expect(v.label, 'Tomate rosa');
expect(v.speciesId, isNotNull);
expect(v.category, 'Solanaceae');
});
}

68
apps/app_seeds/test/domain/species_autoclassify_test.dart Normal file
View file

@ -0,0 +1,68 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:tane/domain/species_autoclassify.dart';
/// A small catalog spanning the tricky cases: accents, multi-word names, a
/// name shared across two species, and substrings that must NOT fire.
const _names = [
SpeciesNameEntry(speciesId: 'zea', name: 'Maíz'),
SpeciesNameEntry(speciesId: 'zea', name: 'Maize'),
SpeciesNameEntry(speciesId: 'zea', name: 'Zea mays'),
SpeciesNameEntry(speciesId: 'tomato', name: 'Tomate'),
SpeciesNameEntry(speciesId: 'tomato', name: 'Tomato'),
SpeciesNameEntry(speciesId: 'bean', name: 'Common bean'),
SpeciesNameEntry(speciesId: 'faba', name: 'Broad bean'),
SpeciesNameEntry(speciesId: 'faba', name: 'Haba'),
SpeciesNameEntry(speciesId: 'pea', name: 'Pea'),
// "Calabaza" is deliberately shared → ambiguous, must stay unclassified.
SpeciesNameEntry(speciesId: 'pepo', name: 'Calabaza'),
SpeciesNameEntry(speciesId: 'maxima', name: 'Calabaza'),
];
void main() {
String? match(String label) => matchSpeciesInLabel(label, _names);
test('matches a common name embedded in a free-text label', () {
expect(match('Maíz de la abuela'), 'zea');
expect(match('Tomate cherry'), 'tomato');
});
test('is accent- and case-insensitive', () {
expect(match('MAIZ dulce'), 'zea'); // no accent, upper-case
expect(match('tomate rosa'), 'tomato');
});
test('matches the scientific name too', () {
expect(match('Zea mays landrace'), 'zea');
});
test('matches multi-word names as a contiguous phrase', () {
expect(match('Broad bean Aquadulce'), 'faba');
expect(match('Common bean from grandma'), 'bean');
});
test('prefers the longest (most specific) name', () {
// "bean" alone is not in the catalog, but the two-word names should win
// over any single-word coincidence.
expect(match('Broad bean'), 'faba');
});
test('folds a plural label word to a singular catalog name', () {
expect(match('Tomates de rama'), 'tomato');
expect(match('Habas de mi huerto'), 'faba');
});
test('does not fire on a substring that is not a whole word', () {
expect(match('Habanero picante'), isNull); // contains "haba" as substring
expect(match('Peach tree'), isNull); // contains "pea" as substring
});
test('returns null when a name is shared across species (ambiguous)', () {
expect(match('Calabaza de invierno'), isNull);
});
test('returns null when nothing matches', () {
expect(match('Girasol gigante'), isNull);
expect(match(' '), isNull);
expect(match(''), isNull);
});
}

159
apps/app_seeds/test/tool/gen_species_catalog_test.dart Normal file
View file

@ -0,0 +1,159 @@
import 'package:flutter_test/flutter_test.dart';
import '../../tool/gen_species_catalog.dart';
void main() {
group('isVernacularName', () {
test('accepts genuine common names', () {
expect(isVernacularName('Tomate', 'solanum lycopersicum'), isTrue);
expect(isVernacularName("Queen Anne's lace", 'daucus carota'), isTrue);
expect(isVernacularName('番茄', 'solanum lycopersicum'), isTrue);
});
test('rejects the scientific name itself', () {
expect(
isVernacularName('Solanum lycopersicum', 'solanum lycopersicum'),
isFalse,
);
});
test('rejects scientific noise: commas, parentheses, ranks, initials', () {
expect(isVernacularName('Remusatia formosana , Hayata', 'x'), isFalse);
expect(isVernacularName('滇常山（原变种）', 'x'), isFalse);
expect(isVernacularName('Brassica oleracea var. acephala', 'x'), isFalse);
expect(isVernacularName('Z. mays', 'x'), isFalse);
expect(isVernacularName('Allium cepa L.', 'x'), isFalse);
expect(isVernacularName('Prunus × domestica', 'x'), isFalse);
});
});
group('buildCatalog', () {
test('emits version 3 and sorts by scientific name', () {
final catalog = buildCatalog([
SpeciesRecord(
qid: 'Q2',
scientificName: 'Zea mays',
common: {
'en': {'Maize'},
},
),
SpeciesRecord(
qid: 'Q1',
scientificName: 'Allium cepa',
common: {
'en': {'Onion'},
},
),
], const {});
expect(catalog['version'], 3);
expect((catalog['species'] as List).map((e) => e['scientific_name']), [
'Allium cepa',
'Zea mays',
]);
});
test('dedups by scientific name, merging names and backfilling ids', () {
final catalog = buildCatalog([
SpeciesRecord(
qid: 'Q13223',
scientificName: 'Solanum lycopersicum',
family: 'Solanaceae',
common: {
'es': {'tomate'},
},
),
SpeciesRecord(
qid: 'Q-dupe',
scientificName: 'Solanum lycopersicum',
gbifKey: 2930137,
common: {
'en': {'tomato'},
'es': {'tomatera'},
},
),
], const {});
final entry = (catalog['species'] as List).single as Map;
expect(entry['wikidata_qid'], 'Q13223'); // first entity kept
expect(entry['family'], 'Solanaceae');
expect(entry['gbif_key'], 2930137); // backfilled from the duplicate
expect(entry['common']['es'], containsAll(['tomate', 'tomatera']));
expect(entry['common']['en'], ['tomato']);
});
test('drops names that are not real vernaculars', () {
final catalog = buildCatalog([
SpeciesRecord(
qid: 'Q1',
scientificName: 'Solanum lycopersicum',
common: {
'es': {'Solanum lycopersicum', 'Tomate'},
},
),
], const {});
expect((catalog['species'] as List).single['common']['es'], ['Tomate']);
});
test('minLanguages is a relevance floor for Wikidata-only species', () {
final records = [
SpeciesRecord(
qid: 'Q1',
scientificName: 'Obscura ignota',
common: {
'zh': {'仅中文'},
},
),
SpeciesRecord(
qid: 'Q2',
scientificName: 'Nota bene',
common: {
'en': {'well known'},
'es': {'bien conocida'},
},
),
];
final kept =
(buildCatalog(records, const {}, minLanguages: 2)['species'] as List)
.map((e) => e['scientific_name'])
.toList();
expect(kept, ['Nota bene']); // the 1-language species is filtered out
});
test('curated overrides win, come first, and bypass the floor', () {
final catalog = buildCatalog(
[
SpeciesRecord(
qid: 'Q081',
scientificName: 'Daucus carota',
family: 'Apiaceae',
common: {
// Wikidata's messy taxon labels for the wild carrot.
'en': {'Devil’s Plague', 'wild carrot'},
},
),
],
const {
'Daucus carota': CuratedOverride(
family: 'Apiaceae',
viabilityYears: 3,
common: {
'es': ['Zanahoria'],
'en': ['Carrot'],
},
),
},
// Would be filtered as it has only one Wikidata language, but curated
// species are always kept.
minLanguages: 4,
);
final entry = (catalog['species'] as List).single as Map;
expect(entry['viability_years'], 3);
expect(entry['common']['es'], ['Zanahoria']);
// Curated name first, then the Wikidata vernaculars.
expect(entry['common']['en'].first, 'Carrot');
expect(entry['common']['en'], contains('wild carrot'));
});
});
}

53
apps/app_seeds/test/ui/variety_detail_screen_test.dart
View file

@ -76,6 +76,59 @@ void main() {
await disposeTree(tester);
});
testWidgets('typing a name suggests the species and links it on tap', (
tester,
) async {
final species = newTestSpeciesRepository(db);
await species.seedBundled(const [
SpeciesSeed(
scientificName: 'Zea mays',
family: 'Poaceae',
commonNames: {
'en': ['Maize'],
'es': ['Maíz'],
},
),
]);
final repo = newTestRepository(db);
// A label that names no species yet, so nothing is auto-linked on create.
final id = await repo.addQuickVariety(label: 'Grandma seed');
await tester.pumpWidget(
wrapDetail(repository: repo, varietyId: id, species: species),
);
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('detail.edit')));
await tester.pumpAndSettle();
await tester.enterText(
find.byKey(const Key('editVariety.name')),
'Maize criollo',
);
await tester.pumpAndSettle();
// The suggestion surfaces from the typed name.
final suggestion = find.byKey(const Key('editVariety.speciesSuggestion'));
expect(suggestion, findsOneWidget);
expect(find.text('Maize (Zea mays)'), findsOneWidget);
await tester.tap(suggestion);
await tester.pumpAndSettle();
// Picking fills the species field with the catalog label.
expect(find.text('Maize (Zea mays)'), findsOneWidget);
final save = find.byKey(const Key('editVariety.save'));
await tester.ensureVisible(save);
await tester.pumpAndSettle();
await tester.tap(save, warnIfMissed: false);
await tester.pumpAndSettle();
// The linked species now shows on the detail header (driven by the stream).
expect(find.text('Zea mays'), findsOneWidget);
await disposeTree(tester);
});
testWidgets('adding a lot shows it in the list', (tester) async {
final repo = newTestRepository(db);
final id = await repo.addQuickVariety(label: 'Bean');

56
apps/app_seeds/tool/README.md Normal file
View file

@ -0,0 +1,56 @@
# Species catalog generator
Regenerates [`assets/catalog/species.json`](../assets/catalog/species.json) — the
bundled, offline, multilingual catalog of edible / cultivated plant species the
app seeds into the encrypted database at first run.
```sh
cd apps/app_seeds
dart run tool/gen_species_catalog.dart # writes species.json (version 3)
dart run tool/gen_species_catalog.dart --dry # prints stats, writes nothing
```
The generated JSON is **committed** to the repo — the app never queries the
network for it (local-first, offline).
## Sources & licensing
- **Names** come only from **Wikidata** labels and aliases. Wikidata is **CC0**
(public domain), so the bundled data carries **no attribution burden** and is
clean for redistribution under the app's AGPL-3.0 license.
- **`gbif_key`** links the [GBIF](https://www.gbif.org/) taxonomic backbone. It
is used **only as an identifier** (a fact, not copyrightable text) — no GBIF
vernacular text is bundled, so no CC-BY attribution is triggered.
- **Curated core crops** (names, family and `viability_years`) live in
[`curated_overrides.json`](curated_overrides.json), hand-maintained. For a
listed species the curated common names **win** (placed first, never dropped)
and its family/viability override Wikidata; Wikidata still adds more languages.
A curated species is always kept even if it would miss the relevance floor.
- **`viability_years`** (seed longevity) is **not** in Wikidata — it comes only
from the curated overrides (public-domain agricultural-extension figures).
Species without an entry simply get no age-based expiry warning.
## What it does
1. **Phase 1 — species list (SPARQL):** taxa with a binomial name that are a
*crop* (`P279* Q235352`), the source/ingredient of a *food*
(`P1672`/`P366`/reverse `P1582` → `P279* Q2095`), with scientific name
(`P225`) and GBIF key (`P846`).
2. **Phase 2 — names + family:** `rdfs:label` (primary) + `skos:altLabel`
(aliases), batched over the species and filtered to the bundled languages;
the family is walked up `P171*` to the family-rank ancestor.
3. **Transform (`buildCatalog`, pure & unit-tested):** dedup by scientific name;
drop non-vernacular noise (the binomial itself, author citations, `var.`/`×`
ranks, abbreviated initials); merge the curated overrides (authoritative,
first); require a real vernacular in **≥ 4 languages** as a relevance floor so
the long tail of obscure single-label taxa is dropped; sort; serialize.
The current run yields **~1200 species** (`assets/catalog/species.json` ≈ 1.5 MB).
## Bundled languages
`es, en, fr, de, it, pt, ca, gl, eu, ar, zh, ja, ru` — a multilingual **seed**,
not a ceiling (Latin + Arabic RTL + CJK + Cyrillic). Edit `kCatalogLanguages` in
[`gen_species_catalog.dart`](gen_species_catalog.dart) to widen coverage, then
regenerate. A species with no name in any bundled language is dropped (add its
language rather than assuming es/en).

19
apps/app_seeds/tool/curated_overrides.json Normal file
View file

@ -0,0 +1,19 @@
{
"note": "Hand-curated, authoritative data for core crops, merged into the generated catalog by gen_species_catalog.dart. For a listed species the curated common names win (placed first, never dropped by the vernacular filter), and its family/viability_years override Wikidata; Wikidata still enriches with additional languages. A curated species is always kept even if it would miss the relevance floor. `viability_years` is public-domain agricultural-extension seed longevity (Wikidata has none); a conservative single value used to warn about aging lots. Extend this list to pin the names of species that matter to your community.",
"species": {
"Solanum lycopersicum": { "family": "Solanaceae", "viability_years": 5, "common": { "es": ["Tomate"], "en": ["Tomato"] } },
"Solanum melongena": { "family": "Solanaceae", "viability_years": 5, "common": { "es": ["Berenjena"], "en": ["Aubergine", "Eggplant"] } },
"Capsicum annuum": { "family": "Solanaceae", "viability_years": 3, "common": { "es": ["Pimiento", "Guindilla"], "en": ["Pepper", "Chilli"] } },
"Phaseolus vulgaris": { "family": "Fabaceae", "viability_years": 3, "common": { "es": ["Judía", "Alubia", "Habichuela"], "en": ["Common bean"] } },
"Vicia faba": { "family": "Fabaceae", "viability_years": 4, "common": { "es": ["Haba"], "en": ["Broad bean", "Fava bean"] } },
"Pisum sativum": { "family": "Fabaceae", "viability_years": 3, "common": { "es": ["Guisante"], "en": ["Pea"] } },
"Zea mays": { "family": "Poaceae", "viability_years": 2, "common": { "es": ["Maíz"], "en": ["Maize", "Corn"] } },
"Cucurbita pepo": { "family": "Cucurbitaceae", "viability_years": 5, "common": { "es": ["Calabacín", "Calabaza"], "en": ["Courgette", "Zucchini", "Squash"] } },
"Cucumis sativus": { "family": "Cucurbitaceae", "viability_years": 5, "common": { "es": ["Pepino"], "en": ["Cucumber"] } },
"Lactuca sativa": { "family": "Asteraceae", "viability_years": 3, "common": { "es": ["Lechuga"], "en": ["Lettuce"] } },
"Beta vulgaris": { "family": "Amaranthaceae", "viability_years": 4, "common": { "es": ["Acelga", "Remolacha"], "en": ["Chard", "Beetroot"] } },
"Allium cepa": { "family": "Amaryllidaceae", "viability_years": 1, "common": { "es": ["Cebolla"], "en": ["Onion"] } },
"Allium sativum": { "family": "Amaryllidaceae", "viability_years": 1, "common": { "es": ["Ajo"], "en": ["Garlic"] } },
"Daucus carota": { "family": "Apiaceae", "viability_years": 3, "common": { "es": ["Zanahoria"], "en": ["Carrot"] } }
}
}

368
apps/app_seeds/tool/gen_species_catalog.dart Normal file
View file

@ -0,0 +1,368 @@
// Regenerates the bundled species catalog (`assets/catalog/species.json`) from
// Wikidata (CC0). Dev-only tool — it is NOT shipped in the app; the app only
// reads the committed JSON it produces (local-first, offline).
//
// dart run tool/gen_species_catalog.dart # writes species.json (v3)
// dart run tool/gen_species_catalog.dart --dry # prints stats, writes nothing
//
// Names come only from Wikidata labels/aliases (CC0 → no attribution burden).
// GBIF is used solely as an identifier (`gbif_key`, a fact, not copyrightable).
// Seed-longevity (`viability_years`) and authoritative core-crop names are
// merged from the hand-maintained `tool/curated_overrides.json`. See
// `tool/README.md`.
//
// The pure transform (`buildCatalog`) is separated from the network fetch so it
// is unit-testable without hitting the endpoint.
import 'dart:convert';
import 'dart:io';
/// Locale set bundled at launch — a multilingual seed, not a ceiling. Covers
/// Latin, Arabic (RTL), CJK (Chinese + Japanese) and Cyrillic scripts. Order
/// here is the order common names are written in the JSON.
const List<String> kCatalogLanguages = [
'es',
'en',
'fr',
'de',
'it',
'pt',
'ca',
'gl',
'eu',
'ar',
'zh',
'ja',
'ru',
];
const String _endpoint = 'https://query.wikidata.org/sparql';
/// Wikimedia asks bots to send a descriptive, contactable User-Agent.
const String _userAgent =
'TanemakiSpeciesCatalogBot/1.0 (https://tanemaki.app; vjrj@comunes.org)';
const String _catalogNote =
'Edible / cultivated plant species, generated from Wikidata (CC0) by '
'tool/gen_species_catalog.dart — see tool/README.md to regenerate. `common` '
'is a locale-keyed map (Wikidata labels + aliases) the app resolves by the '
"user's locale with graceful fallback, never assuming es/en only. "
'`gbif_key` links the GBIF taxonomic backbone (identifier only). '
'`viability_years` is public-domain agricultural-extension seed longevity '
'merged from tool/curated_overrides.json (not in Wikidata); a conservative '
'single value used to warn about aging lots.';
/// Hand-curated, authoritative data for a core crop (from
/// `curated_overrides.json`). Its names win over Wikidata's; its family and
/// viability override; a curated species is always kept.
class CuratedOverride {
const CuratedOverride({
this.family,
this.viabilityYears,
this.common = const {},
});
final String? family;
final int? viabilityYears;
final Map<String, List<String>> common;
}
/// One aggregated species before it is serialized. Mutable during aggregation.
class SpeciesRecord {
SpeciesRecord({
required this.qid,
required this.scientificName,
this.family,
this.gbifKey,
Map<String, Set<String>>? common,
}) : common = common ?? {};
final String qid;
final String scientificName;
String? family;
int? gbifKey;
/// language code → set of names (dedup, insertion-ordered).
final Map<String, Set<String>> common;
}
/// Whether [name] reads as a genuine vernacular rather than a scientific name,
/// synonym or author citation. Wikidata aliases are full of the latter (commas,
/// parentheses, hybrid `×`, `var.`/`subsp.` ranks, or a straight repeat of the
/// binomial); those are noise in a common-name list.
bool isVernacularName(String name, String scientificNameLower) {
final n = name.trim();
if (n.isEmpty) return false;
if (n.toLowerCase() == scientificNameLower) return false;
// Commas/parentheses (ASCII and CJK full-width) and the hybrid sign mark
// author citations, synonym lists and hybrid formulas — never a vernacular.
if (n.contains(RegExp(r'[,()（），×]'))) return false;
if (n.contains(RegExp(r'\b(var|subsp|ssp|f|cv|nothosubsp)\.'))) return false;
// A lone initial + period is an abbreviated genus or author citation
// ("Z. mays", "Allium cepa L."), not a vernacular.
if (n.contains(RegExp(r'\b[A-Z]\.'))) return false;
return true;
}
/// Pure transform: dedup by scientific name, keep only [languages], drop
/// non-vernacular noise, require a name in at least [minLanguages] languages
/// (a relevance floor — obscure taxa carry a vernacular in only one), merge the
/// hand-curated [curated] overrides (authoritative names/family/viability that
/// win over Wikidata and are always kept), and emit an ordered, JSON-ready
/// catalog map (`{version, note, species: [...]}`). No network, no I/O.
Map<String, dynamic> buildCatalog(
Iterable<SpeciesRecord> records,
Map<String, CuratedOverride> curated, {
List<String> languages = kCatalogLanguages,
int minLanguages = 1,
}) {
// Dedup by scientific name; merge names and backfill family/gbif across the
// duplicate entities Wikidata sometimes has for one accepted binomial.
final byName = <String, SpeciesRecord>{};
for (final r in records) {
final name = r.scientificName.trim();
if (name.isEmpty) continue;
final existing = byName[name];
if (existing == null) {
byName[name] = r;
continue;
}
existing.family ??= r.family;
existing.gbifKey ??= r.gbifKey;
for (final entry in r.common.entries) {
existing.common.putIfAbsent(entry.key, () => {}).addAll(entry.value);
}
}
final species = <Map<String, dynamic>>[];
for (final r in byName.values) {
final sciLower = r.scientificName.trim().toLowerCase();
final override = curated[r.scientificName];
final common = <String, List<String>>{};
for (final lang in languages) {
final ordered = <String>[];
final seen = <String>{};
// Curated names first (authoritative, kept as-is), then Wikidata's
// vernaculars, de-duplicated case-insensitively.
for (final n in override?.common[lang] ?? const <String>[]) {
if (n.trim().isNotEmpty && seen.add(n.toLowerCase())) ordered.add(n);
}
for (final n in r.common[lang] ?? const <String>{}) {
final v = n.trim();
if (!isVernacularName(v, sciLower)) continue;
if (seen.add(v.toLowerCase())) ordered.add(v);
}
if (ordered.isNotEmpty) common[lang] = ordered;
}
// A relevance floor for Wikidata-only species: obscure taxa carry a real
// vernacular in only one language (a lone CJK/Cyrillic label), well-known
// crops in many. Curated species bypass the floor.
if (override == null && common.length < minLanguages) continue;
if (common.isEmpty) continue;
final family = override?.family ?? r.family;
final viability = override?.viabilityYears;
species.add({
'scientific_name': r.scientificName,
'family': ?family,
'wikidata_qid': r.qid,
if (r.gbifKey != null) 'gbif_key': r.gbifKey,
'common': common,
'viability_years': ?viability,
});
}
species.sort(
(a, b) => (a['scientific_name'] as String).compareTo(
b['scientific_name'] as String,
),
);
return {'version': 3, 'note': _catalogNote, 'species': species};
}
Future<void> main(List<String> args) async {
final dryRun = args.contains('--dry');
final toolDir = File(Platform.script.toFilePath()).parent;
final overridesFile = File('${toolDir.path}/curated_overrides.json');
final outFile = File('${toolDir.path}/../assets/catalog/species.json');
final curated = _readCuratedOverrides(overridesFile);
stdout.writeln('Loaded ${curated.length} curated overrides.');
final client = HttpClient()..userAgent = _userAgent;
try {
stdout.writeln('Querying Wikidata for edible/cultivated species…');
final skeleton = await _fetchSpeciesSkeleton(client);
stdout.writeln(
'Found ${skeleton.length} candidate species. Fetching '
'names in ${kCatalogLanguages.length} languages…',
);
await _fetchLabels(client, skeleton);
final catalog = buildCatalog(skeleton.values, curated, minLanguages: 4);
final count = (catalog['species'] as List).length;
stdout.writeln('Built catalog: $count species with bundled-locale names.');
if (dryRun) {
stdout.writeln('--dry: not writing ${outFile.path}');
return;
}
const encoder = JsonEncoder.withIndent(' ');
await outFile.writeAsString('${encoder.convert(catalog)}\n');
stdout.writeln('Wrote ${outFile.path}');
} finally {
client.close();
}
}
Map<String, CuratedOverride> _readCuratedOverrides(File file) {
if (!file.existsSync()) return {};
final data = jsonDecode(file.readAsStringSync()) as Map<String, dynamic>;
final species = (data['species'] as Map<String, dynamic>);
return species.map((name, raw) {
final o = raw as Map<String, dynamic>;
final common = (o['common'] as Map<String, dynamic>? ?? const {}).map(
(lang, names) => MapEntry(lang, (names as List).cast<String>()),
);
return MapEntry(
name,
CuratedOverride(
family: o['family'] as String?,
viabilityYears: (o['viability_years'] as num?)?.toInt(),
common: common,
),
);
});
}
/// Phase 1: the list of species QIDs with scientific name, family and GBIF key.
Future<Map<String, SpeciesRecord>> _fetchSpeciesSkeleton(
HttpClient client,
) async {
// Taxa with a binomial (or lower) scientific name — CONTAINS(" ") keeps
// species and botanical varieties (relevant for seed savers: e.g. the many
// Brassica oleracea var. cultivars) while dropping genus-level rows — that are
// edible/cultivated, reached three ways: a crop, the source of a food, or the
// source of a food ingredient. Taxon rank is intentionally not required: many
// cultivated taxa in Wikidata leave P105 unset.
const query = r'''
SELECT ?item ?sci ?gbif WHERE {
?item wdt:P225 ?sci .
FILTER(CONTAINS(?sci, " "))
{
?item wdt:P279* wd:Q235352 . # a crop
} UNION {
?item wdt:P1672 ?use . # this taxon is source of …
?use wdt:P279* wd:Q2095 . # … a food
} UNION {
?item wdt:P1672 ?use .
?use wdt:P279* wd:Q25403900 . # … a food ingredient
} UNION {
?food wdt:P1582 ?item . # … the natural source of a food
?food wdt:P279* wd:Q2095 .
} UNION {
?item wdt:P366 ?use . # this taxon has use …
?use wdt:P279* wd:Q2095 . # … food
}
OPTIONAL { ?item wdt:P846 ?gbif . }
}''';
final rows = await _runSparql(client, query);
final out = <String, SpeciesRecord>{};
for (final row in rows) {
final qid = _qid(row['item']?['value'] as String?);
final sci = row['sci']?['value'] as String?;
if (qid == null || sci == null) continue;
final rec = out.putIfAbsent(
qid,
() => SpeciesRecord(qid: qid, scientificName: sci),
);
final gbif = row['gbif']?['value'] as String?;
if (gbif != null) rec.gbifKey ??= int.tryParse(gbif);
}
return out;
}
/// Phase 2: labels + aliases (and the family, walked up `P171*`) in the bundled
/// languages, batched over QIDs to keep each query under the endpoint timeout.
Future<void> _fetchLabels(
HttpClient client,
Map<String, SpeciesRecord> skeleton,
) async {
final langFilter = kCatalogLanguages.map((l) => '"$l"').join(', ');
final qids = skeleton.keys.toList();
const batchSize = 100;
for (var i = 0; i < qids.length; i += batchSize) {
final batch = qids.skip(i).take(batchSize);
final values = batch.map((q) => 'wd:$q').join(' ');
// `kind` orders the primary label ("a", rdfs:label — usually the real
// vernacular) ahead of aliases ("b", skos:altLabel — often synonyms).
final query =
'''
SELECT ?item ?label ?kind ?family WHERE {
VALUES ?item { $values }
OPTIONAL {
?item wdt:P171* ?fam . # walk up to the family-rank ancestor
?fam wdt:P105 wd:Q35409 ;
wdt:P225 ?family .
}
{ ?item rdfs:label ?label . BIND("a" AS ?kind) }
UNION
{ ?item skos:altLabel ?label . BIND("b" AS ?kind) }
FILTER(LANG(?label) IN ($langFilter))
}''';
final rows = await _runSparql(client, query);
// Primary labels first so they land first in each language's ordered set.
rows.sort(
(a, b) => (a['kind']?['value'] as String? ?? 'b').compareTo(
b['kind']?['value'] as String? ?? 'b',
),
);
for (final row in rows) {
final qid = _qid(row['item']?['value'] as String?);
final label = row['label'];
if (qid == null || label == null) continue;
final rec = skeleton[qid];
if (rec == null) continue;
rec.family ??= row['family']?['value'] as String?;
final lang = label['xml:lang'] as String?;
final value = label['value'] as String?;
if (lang == null || value == null) continue;
rec.common.putIfAbsent(lang, () => {}).add(value);
}
stdout.writeln(
' labels: ${(i + batchSize).clamp(0, qids.length)}'
'/${qids.length}',
);
}
}
/// Runs a SPARQL SELECT and returns the `results.bindings` list.
Future<List<Map<String, dynamic>>> _runSparql(
HttpClient client,
String query,
) async {
final uri = Uri.parse(
_endpoint,
).replace(queryParameters: {'query': query, 'format': 'json'});
final request = await client.getUrl(uri);
request.headers.set(
HttpHeaders.acceptHeader,
'application/sparql-results+json',
);
final response = await request.close();
if (response.statusCode != 200) {
final body = await response.transform(utf8.decoder).join();
throw HttpException('SPARQL ${response.statusCode}: $body');
}
final body = await response.transform(utf8.decoder).join();
final decoded = jsonDecode(body) as Map<String, dynamic>;
final bindings = (decoded['results']?['bindings'] as List?) ?? const [];
return bindings.cast<Map<String, dynamic>>();
}
/// Extracts the `Qxxxx` id from a Wikidata entity URI.
String? _qid(String? uri) {
if (uri == null) return null;
final i = uri.lastIndexOf('/');
return i == -1 ? uri : uri.substring(i + 1);
}