unofficial_jisho_api_dart/lib/src/objects.dart

/* -------------------------------------------------------------------------- */
/*                       searchForKanji related classes                       */
/* -------------------------------------------------------------------------- */

class YomiExample {
  String example;
  String reading;
  String meaning;

  YomiExample({this.example, this.reading, this.meaning});

  Map<String, String> toJson() =>
      {'example': example, 'reading': reading, 'meaning': meaning};
}

class Radical {
  String symbol;
  List<String> forms;
  String meaning;

  Radical({this.symbol, this.forms, this.meaning});

  Map<String, dynamic> toJson() =>
      {'symbol': symbol, 'forms': forms, 'meaning': meaning};
}

class KanjiResult {
  String query;
  bool found;

  String taughtIn;
  String jlptLevel;
  int newspaperFrequencyRank;
  int strokeCount;
  String meaning;
  List<String> kunyomi;
  List<String> onyomi;
  List<YomiExample> kunyomiExamples;
  List<YomiExample> onyomiExamples;
  Radical radical;
  List<String> parts;
  String strokeOrderDiagramUri;
  String strokeOrderSvgUri;
  String strokeOrderGifUri;
  String uri;

  KanjiResult(
      {this.query,
      this.found,
      this.taughtIn,
      this.jlptLevel,
      this.newspaperFrequencyRank,
      this.strokeCount,
      this.meaning,
      this.kunyomi,
      this.onyomi,
      this.kunyomiExamples,
      this.onyomiExamples,
      this.radical,
      this.parts,
      this.strokeOrderDiagramUri,
      this.strokeOrderSvgUri,
      this.strokeOrderGifUri,
      this.uri});

  Map<String, dynamic> toJson() {
    return {
      'query': query,
      'found': found,
      'taughtIn': taughtIn,
      'jlptLevel': jlptLevel,
      'newspaperFrequencyRank': newspaperFrequencyRank,
      'strokeCount': strokeCount,
      'meaning': meaning,
      'kunyomi': kunyomi,
      'onyomi': onyomi,
      'onyomiExamples': onyomiExamples,
      'kunyomiExamples': kunyomiExamples,
      'radical': (radical != null) ? radical.toJson() : null,
      'parts': parts,
      'strokeOrderDiagramUri': strokeOrderDiagramUri,
      'strokeOrderSvgUri': strokeOrderSvgUri,
      'strokeOrderGifUri': strokeOrderGifUri,
      'uri': uri
    };
  }
}

/* -------------------------------------------------------------------------- */
/*                      searchForExamples related classes                     */
/* -------------------------------------------------------------------------- */

class ExampleSentencePiece {
  String lifted;
  String unlifted;

  ExampleSentencePiece({this.lifted, this.unlifted});

  Map<String, dynamic> toJson() {
    return {'lifted': lifted, 'unlifted': unlifted};
  }
}

class ExampleResultData {
  String kanji;
  String kana;
  String english;
  List<ExampleSentencePiece> pieces;

  ExampleResultData({this.english, this.kanji, this.kana, this.pieces});

  Map<String, dynamic> toJson() {
    return {'english': english, 'kanji': kanji, 'kana': kana, 'pieces': pieces};
  }
}

class ExampleResults {
  String query;
  bool found;
  String uri;
  List<ExampleResultData> results;
  String phrase;

  ExampleResults({this.query, this.found, this.results, this.uri, this.phrase});

  Map<String, dynamic> toJson() {
    return {
      'query': query,
      'found': found,
      'results': results,
      'uri': uri,
      'phrase': phrase
    };
  }
}

/* -------------------------------------------------------------------------- */
/*                       scrapeForPhrase related classes                      */
/* -------------------------------------------------------------------------- */

class PhraseScrapeSentence {
  String english;
  String japanese;
  List<ExampleSentencePiece> pieces;

  PhraseScrapeSentence({this.english, this.japanese, this.pieces});

  Map<String, dynamic> toJson() =>
      {'english': english, 'japanese': japanese, 'pieces': pieces};
}

class PhraseScrapeMeaning {
  List<String> seeAlsoTerms;
  List<PhraseScrapeSentence> sentences;
  String definition;
  List<String> supplemental;
  String definitionAbstract;
  List<String> tags;

  PhraseScrapeMeaning(
      {this.seeAlsoTerms,
      this.sentences,
      this.definition,
      this.supplemental,
      this.definitionAbstract,
      this.tags});

  Map<String, dynamic> toJson() => {
        'seeAlsoTerms': seeAlsoTerms,
        'sentences': sentences,
        'definition': definition,
        'supplemental': supplemental,
        'definitionAbstract': definitionAbstract,
        'tags': tags
      };
}

class KanjiKanaPair {
  String kanji;
  String kana;

  KanjiKanaPair({this.kanji, this.kana});

  Map<String, String> toJson() => {'kanji': kanji, 'kana': kana};
}

class PhrasePageScrapeResult {
  bool found;
  String query;
  String uri;
  List<String> tags;
  List<PhraseScrapeMeaning> meanings;
  List<KanjiKanaPair> otherForms;
  List<String> notes;

  PhrasePageScrapeResult(
      {this.found,
      this.query,
      this.uri,
      this.tags,
      this.meanings,
      this.otherForms,
      this.notes});

  Map<String, dynamic> toJson() => {
        'found': found,
        'query': query,
        'uri': uri,
        'tags': tags,
        'meanings': meanings,
        'otherForms': otherForms,
        'notes': notes
      };
}

/* -------------------------------------------------------------------------- */
/*                       searchForPhrase related classes                      */
/* -------------------------------------------------------------------------- */

class JishoJapaneseWord {
  String word;
  String reading;

  JishoJapaneseWord({this.word, this.reading});

  factory JishoJapaneseWord.fromJson(Map<String, dynamic> json) {
    return JishoJapaneseWord(
        word: json['word'] as String, reading: json['reading'] as String);
  }

  Map<String, dynamic> toJson() => {'word': word, 'reading': reading};
}

class JishoSenseLink {
  String text;
  String url;

  JishoSenseLink({this.text, this.url});

  factory JishoSenseLink.fromJson(Map<String, dynamic> json) {
    return JishoSenseLink(
        text: json['text'] as String, url: json['url'] as String);
  }

  Map<String, dynamic> toJson() => {'text': text, 'url': url};
}

class JishoWordSense {
  List<String> english_definitions;
  List<String> parts_of_speech;
  List<JishoSenseLink> links;
  List<String> tags;
  List<String> see_also;
  List<String> antonyms;
  List<dynamic> source;
  List<String> info;
  List<dynamic> restrictions;

  JishoWordSense(
      {this.english_definitions,
      this.parts_of_speech,
      this.links,
      this.tags,
      this.see_also,
      this.antonyms,
      this.source,
      this.info,
      this.restrictions});

  factory JishoWordSense.fromJson(Map<String, dynamic> json) {
    return JishoWordSense(
        english_definitions: (json['english_definitions'] as List)
            .map((result) => result as String)
            .toList(),
        parts_of_speech: (json['parts_of_speech'] as List)
            .map((result) => result as String)
            .toList(),
        links: (json['links'] as List)
            .map((result) => JishoSenseLink.fromJson(result))
            .toList(),
        tags: (json['tags'] as List).map((result) => result as String).toList(),
        see_also: (json['see_also'] as List)
            .map((result) => result as String)
            .toList(),
        antonyms: (json['antonyms'] as List)
            .map((result) => result as String)
            .toList(),
        source: json['source'] as List<dynamic>,
        info: (json['info'] as List).map((result) => result as String).toList(),
        restrictions: json['restrictions'] as List<dynamic>);
  }

  Map<String, dynamic> toJson() => {
        'english_definitions': english_definitions,
        'parts_of_speech': parts_of_speech,
        'links': links,
        'tags': tags,
        'see_also': see_also,
        'antonyms': antonyms,
        'source': source,
        'info': info,
        'restrictions': restrictions
      };
}

class JishoAttribution {
  bool jmdict;
  bool jmnedict;
  String dbpedia;

  JishoAttribution({this.jmdict, this.jmnedict, this.dbpedia});

  factory JishoAttribution.fromJson(Map<String, dynamic> json) {
    return JishoAttribution(
        jmdict: (json['jmdict'].toString() == 'true'),
        jmnedict: (json['jmnedict'].toString() == 'true'),
        dbpedia: (json['dbpedia'].toString() != 'false')
            ? json['dbpedia'].toString()
            : null);
  }

  Map<String, dynamic> toJson() =>
      {'jmdict': jmdict, 'jmnedict': jmnedict, 'dbpedia': dbpedia};
}

class JishoResult {
  String slug;
  bool is_common;
  List<String> tags;
  List<String> jlpt;
  List<JishoJapaneseWord> japanese;
  List<JishoWordSense> senses;
  JishoAttribution attribution;

  JishoResult(
      {this.slug,
      this.is_common,
      this.tags,
      this.jlpt,
      this.japanese,
      this.senses,
      this.attribution});

  factory JishoResult.fromJson(Map<String, dynamic> json) {
    return JishoResult(
        slug: json['slug'] as String,
        is_common: json['is_common'] as bool,
        tags: (json['tags'] as List).map((result) => result as String).toList(),
        jlpt: (json['jlpt'] as List).map((result) => result as String).toList(),
        japanese: (json['japanese'] as List)
            .map((result) => JishoJapaneseWord.fromJson(result))
            .toList(),
        senses: (json['senses'] as List)
            .map((result) => JishoWordSense.fromJson(result))
            .toList(),
        attribution: JishoAttribution.fromJson(json['attribution']));
  }

  Map<String, dynamic> toJson() => {
        'slug': slug,
        'is_common': is_common,
        'tags': tags,
        'jlpt': jlpt,
        'japanese': japanese,
        'senses': senses,
        'attribution': attribution
      };
}

class JishoResultMeta {
  int status;

  JishoResultMeta({this.status});

  factory JishoResultMeta.fromJson(Map<String, dynamic> json) {
    return JishoResultMeta(status: json['status'] as int);
  }

  Map<String, dynamic> toJson() => {'status': status};
}

class JishoAPIResult {
  JishoResultMeta meta;
  List<JishoResult> data;

  JishoAPIResult({this.meta, this.data});

  factory JishoAPIResult.fromJson(Map<String, dynamic> json) {
    return JishoAPIResult(
        meta: JishoResultMeta.fromJson(json['meta']),
        data: (json['data'] as List)
            .map((result) => JishoResult.fromJson(result))
            .toList());
  }

  Map<String, dynamic> toJson() => {'meta': meta.toJson(), 'data': data};
}