glanzlicht / Meinweimar_Tourguide

Intelligenter Tourguide für Weimar

Verified secure showcase
167 Files 833 KB Public size 12 Redacted Dart · Markdown · YAML · HTML · JSON · GITIGNORE

Project overview

Meinweimar_Tourguide is a verified code showcase with 167 visible project entries across 5 top-level modules. The primary detected language is Dart; protected files remain visible in the structure while their contents stay private.

README

MeinWeimar Tourguide

MeinWeimar Tourguide

Eine produktionsnahe Flutter-App fuer Stadtentdeckung, Tourplanung und Sprachlernen in Weimar. Die App verbindet eine responsive mobile und webfaehige Oberflaeche mit einer WordPress-REST-API und macht aus redaktionellen Inhalten konkrete Wege, Orte und Empfehlungen.

Dieses Repository zeigt neben der UI auch die technische Produktarbeit dahinter: API-Integration, Offline-tolerante Datenhaltung, Lokalisierung, Routing, Audio/TTS, Analytics, Deep Links und automatisierte Qualitaetssicherung.

App-Eindruecke

Start · Entdecken · Touren · Karte · Mehr

Produktumfang

  • Entdecken: POIs, Touren, Veranstaltungen, Partner und Themen mit Suche,
  • Filtern und fehlertoleranter Trefferlogik.

  • Unterwegs: Kartenansicht, Standort, Fussgaenger-Routing, Tourfortschritt,
  • Favoriten und eine persoenliche Route aus der eigenen Weimar-Liste.

  • Mehrsprachigkeit: UI und CMS-Inhalte in Deutsch, Englisch,
  • Niederlaendisch, Franzoesisch, Polnisch, Italienisch, Spanisch und Tschechisch.

  • Audio und Lernen: Guide-Audio, Flutter TTS sowie SprachGuide-Kurse und
  • Lern-Touren.

  • Redaktion und Betrieb: WordPress REST API, Oeffnungszeiten mit
  • Zeitzonenlogik, Kampagnen, Partnerplatzierungen, Deep Links und First-Party- Analytics.

  • Responsive UX: kleine Displays, grosse Systemschrift, dynamische
  • Kartenhoehen und versionierte Web-Releases ohne veraltete Service-Worker- Assets.

Technischer Steckbrief

BereichUmsetzung
FrameworkFlutter / Dart 3.4+
PlattformeniOS, Android und Web
DatenWordPress REST API, typisierte Models und Repositories
Kartenflutter_map, latlong2, Standort und Fussgaenger-Routing
Audiojust_audio, flutter_tts
Lokaler ZustandShared Preferences, begrenztes Caching und Analytics-Puffer
QualitaetFlutter Analyzer, Widget- und Service-Tests, Lokalisierungs- und API-Modelltests

Die Codebasis ist nach Verantwortlichkeiten gegliedert:

lib/
	core/          gemeinsame API-, Lokalisierungs- und Navigationslogik
	data/          Datenzugriff und DTO-nahe Strukturen
	features/      produktbezogene Screens und Flows
	models/        fachliche Modelle
	repositories/  Datenzugriff hinter stabilen Schnittstellen
	services/      Routing, Audio, Analytics und Plattformdienste
	widgets/       wiederverwendbare UI-Bausteine
test/            fokussierte Tests fuer Services, Modelle und Widgets

Lokal starten

Voraussetzungen: aktuelles Flutter SDK und das darin enthaltene Dart SDK.

flutter pub get
flutter analyze
flutter test
flutter run -d chrome

Die Anwendung verwendet standardmaessig die oeffentliche API: https://tour.meinweimar.de/wp-json/meinweimar/v1

Web-Release

Fuer einen Web-Release das versionierte Build-Skript verwenden:

./tool/build_web_release.sh

Das Skript legt den Runtime-Build unter build/web/releases/<release-id>/ ab. Launcher und Versionsendpunkt bleiben bewusst nicht cachebar, damit Browser nach einem Reload die aktuelle Version auflosen. Startup-Diagnostik ist nur mit ?mwdebug=1 aktiv.

Dokumentation

  • [Deep Links](DEEP_LINKS.md) - Web-Routen fuer Bereiche, Touren und POIs
  • [Projektstatus](PROJECT_STATE.md) - aktueller Funktions- und Integrationsstand
  • [Changelog](CHANGELOG.md) - nachvollziehbare Produkt- und UX-Iterationen
  • [API-Integration](docs/API_INTEGRATION.md) - technische Integrationsnotizen
lib/models/learning_unit.dartDart
import '../core/text/wp_text.dart';
class LearningTtsRequest {
const LearningTtsRequest({
required this.text,
required this.languageCode,
required this.variant,
});
final String text;
final String languageCode;
final String variant;
factory LearningTtsRequest.fromJson(Map<String, dynamic> json) =>
LearningTtsRequest(
text: WpText.plain(json['text']),
languageCode: '${json['lang'] ?? 'de'}',
variant: '${json['variant'] ?? 'normal'}',
);
}
class LearningAudioItem {
const LearningAudioItem({
required this.text,
required this.languageCode,
required this.variants,
this.requests = const {},
});
final String text;
final String languageCode;
final List<String> variants;
final Map<String, LearningTtsRequest> requests;
LearningTtsRequest requestFor(String variant) =>
requests[variant] ??
LearningTtsRequest(
text: text,
languageCode: languageCode,
variant: variant,
);
factory LearningAudioItem.fromJson(Map<String, dynamic> json) {
final parsedRequests = <String, LearningTtsRequest>{};
final multi = json['requests'];
if (multi is Map) {
for (final entry in multi.entries) {
final value = entry.value;
if (value is Map<String, dynamic>) {
parsedRequests['${entry.key}'] = LearningTtsRequest.fromJson(value);
} else if (value is Map) {
parsedRequests['${entry.key}'] = LearningTtsRequest.fromJson(
value.map((key, val) => MapEntry('$key', val)),
);
}
}
}
final single = json['request'];
if (single is Map<String, dynamic>) {
final request = LearningTtsRequest.fromJson(single);
parsedRequests[request.variant] = request;
} else if (single is Map) {
final request = LearningTtsRequest.fromJson(
single.map((key, val) => MapEntry('$key', val)),
);
parsedRequests[request.variant] = request;
}
return LearningAudioItem(
text: WpText.plain(json['text']),
languageCode: '${json['lang'] ?? 'de'}',
variants: (json['variants'] as List? ?? const ['normal'])
.map((e) => '$e')
.toList(),
requests: parsedRequests,
);
}
}
class LearningAudioBundle {
const LearningAudioBundle({
this.provider,
this.endpoint,
this.method,
this.targetPhrase,
this.help,
this.explanation,
this.challenge,
});
final String? provider;
final String? endpoint;
final String? method;
final LearningAudioItem? targetPhrase;
final LearningAudioItem? help;
final LearningAudioItem? explanation;
final LearningAudioItem? challenge;
static LearningAudioItem? _item(dynamic value) {
if (value is Map<String, dynamic>) return LearningAudioItem.fromJson(value);
if (value is Map) {
return LearningAudioItem.fromJson(
value.map((key, val) => MapEntry('$key', val)));
}
return null;
}
factory LearningAudioBundle.fromJson(Map<String, dynamic> json) =>
LearningAudioBundle(
provider: json['provider']?.toString(),
endpoint: json['endpoint']?.toString(),
method: json['method']?.toString(),
targetPhrase: _item(json['target_phrase']),
help: _item(json['help']),
explanation: _item(json['explanation']),
challenge: _item(json['challenge']),
);
}
class LearningLocation {
const LearningLocation(
{this.poiId, this.poiTitle, this.latitude, this.longitude});
final String? poiId;
final String? poiTitle;
final double? latitude;
final double? longitude;
factory LearningLocation.fromJson(Map<String, dynamic> json) =>
LearningLocation(
poiId: json['poi_id'] == null ? null : '${json['poi_id']}',
poiTitle: WpText.nullablePlain(json['poi_title']),
latitude: (json['latitude'] as num?)?.toDouble(),
longitude: (json['longitude'] as num?)?.toDouble(),
);
}
class LearningUnit {
const LearningUnit({
required this.id,
required this.slug,
required this.title,
required this.courseId,
required this.order,
required this.level,
required this.kind,
required this.phraseDe,
required this.help,
required this.pronunciation,
required this.explanation,
required this.challenge,
this.quizQuestion,
this.quizAnswer,
this.language,
this.resolvedLanguage,
this.availableLanguages = const [],
this.translationContext,
this.location,
this.audio,
});
final String id;
final String slug;
final String title;
final String courseId;
final int order;
final String level;
final String kind;
final String phraseDe;
final String help;
final String pronunciation;
final String explanation;
final String challenge;
final String? quizQuestion;
final String? quizAnswer;
final String? language;
final String? resolvedLanguage;
final List<String> availableLanguages;
final String? translationContext;
final LearningLocation? location;
final LearningAudioBundle? audio;
factory LearningUnit.fromJson(Map<String, dynamic> json) {
final quiz = json['quiz'] is Map<String, dynamic>
? json['quiz'] as Map<String, dynamic>
: null;
final location = json['location'] is Map<String, dynamic>
? LearningLocation.fromJson(json['location'] as Map<String, dynamic>)
: null;
final audio = json['audio'] is Map<String, dynamic>
? LearningAudioBundle.fromJson(json['audio'] as Map<String, dynamic>)
: null;
return LearningUnit(
id: '${json['id'] ?? ''}',
slug: '${json['slug'] ?? ''}',
title: WpText.plain(json['title']),
courseId: '${json['course_id'] ?? ''}',
order: (json['order'] as num?)?.toInt() ?? 0,
level: '${json['level'] ?? 'A1'}',
kind: '${json['kind'] ?? 'phrase'}',
phraseDe: WpText.plain(json['phrase_de']),
help: WpText.plain(json['help']),
pronunciation: WpText.plain(json['pronunciation']),
explanation: WpText.plain(json['explanation']),
challenge: WpText.plain(json['challenge']),
quizQuestion: WpText.nullablePlain(quiz?['question']),
quizAnswer: WpText.nullablePlain(quiz?['answer']),
language: json['language']?.toString(),
resolvedLanguage: json['resolved_language']?.toString(),
availableLanguages: (json['available_languages'] as List? ?? const [])
.map((e) => '$e')
.toList(),
translationContext: WpText.nullablePlain(json['translation_context']),
location: location,
audio: audio,
);
}
}

Architecture

High-level modules detected from the verified public snapshot. Protected implementation details are intentionally omitted.

libmodule
testmodule
docsmodule
webmodule
toolmodule

Technology stack

DartMarkdownLOCKHTMLShellHTACCESSFlutter / Dart
Dart89.9%
Markdown3.9%
LOCK3.1%
HTML1.7%
Shell0.8%
HTACCESS0.2%
YAML0.1%
METADATA0.1%