aac3a729a2
Phase 1 du MVP : schéma SQLite porté depuis le prototype web, seed des règles/récompenses, flux d'onboarding en 4 étapes et écran d'accueil minimal. Co-authored-by: Cursor <cursoragent@cursor.com>
3693 lines
113 KiB
Dart
3693 lines
113 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'app_database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $EnfantsTable extends Enfants with TableInfo<$EnfantsTable, Enfant> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$EnfantsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _prenomMeta = const VerificationMeta('prenom');
|
|
@override
|
|
late final GeneratedColumn<String> prenom = GeneratedColumn<String>(
|
|
'prenom',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _dateNaissanceMeta = const VerificationMeta(
|
|
'dateNaissance',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> dateNaissance = GeneratedColumn<String>(
|
|
'date_naissance',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _scoreMeta = const VerificationMeta('score');
|
|
@override
|
|
late final GeneratedColumn<int> score = GeneratedColumn<int>(
|
|
'score',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
static const VerificationMeta _couleurMeta = const VerificationMeta(
|
|
'couleur',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> couleur = GeneratedColumn<String>(
|
|
'couleur',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('#6C63FF'),
|
|
);
|
|
static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
|
|
@override
|
|
late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
|
|
'ordre',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
prenom,
|
|
dateNaissance,
|
|
score,
|
|
couleur,
|
|
ordre,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'enfants';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Enfant> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('prenom')) {
|
|
context.handle(
|
|
_prenomMeta,
|
|
prenom.isAcceptableOrUnknown(data['prenom']!, _prenomMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_prenomMeta);
|
|
}
|
|
if (data.containsKey('date_naissance')) {
|
|
context.handle(
|
|
_dateNaissanceMeta,
|
|
dateNaissance.isAcceptableOrUnknown(
|
|
data['date_naissance']!,
|
|
_dateNaissanceMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('score')) {
|
|
context.handle(
|
|
_scoreMeta,
|
|
score.isAcceptableOrUnknown(data['score']!, _scoreMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('couleur')) {
|
|
context.handle(
|
|
_couleurMeta,
|
|
couleur.isAcceptableOrUnknown(data['couleur']!, _couleurMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('ordre')) {
|
|
context.handle(
|
|
_ordreMeta,
|
|
ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
List<Set<GeneratedColumn>> get uniqueKeys => [
|
|
{prenom},
|
|
];
|
|
@override
|
|
Enfant map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Enfant(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
prenom: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}prenom'],
|
|
)!,
|
|
dateNaissance: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}date_naissance'],
|
|
),
|
|
score: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}score'],
|
|
)!,
|
|
couleur: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}couleur'],
|
|
)!,
|
|
ordre: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}ordre'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$EnfantsTable createAlias(String alias) {
|
|
return $EnfantsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Enfant extends DataClass implements Insertable<Enfant> {
|
|
final int id;
|
|
final String prenom;
|
|
final String? dateNaissance;
|
|
final int score;
|
|
final String couleur;
|
|
final int ordre;
|
|
const Enfant({
|
|
required this.id,
|
|
required this.prenom,
|
|
this.dateNaissance,
|
|
required this.score,
|
|
required this.couleur,
|
|
required this.ordre,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['prenom'] = Variable<String>(prenom);
|
|
if (!nullToAbsent || dateNaissance != null) {
|
|
map['date_naissance'] = Variable<String>(dateNaissance);
|
|
}
|
|
map['score'] = Variable<int>(score);
|
|
map['couleur'] = Variable<String>(couleur);
|
|
map['ordre'] = Variable<int>(ordre);
|
|
return map;
|
|
}
|
|
|
|
EnfantsCompanion toCompanion(bool nullToAbsent) {
|
|
return EnfantsCompanion(
|
|
id: Value(id),
|
|
prenom: Value(prenom),
|
|
dateNaissance: dateNaissance == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(dateNaissance),
|
|
score: Value(score),
|
|
couleur: Value(couleur),
|
|
ordre: Value(ordre),
|
|
);
|
|
}
|
|
|
|
factory Enfant.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Enfant(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
prenom: serializer.fromJson<String>(json['prenom']),
|
|
dateNaissance: serializer.fromJson<String?>(json['dateNaissance']),
|
|
score: serializer.fromJson<int>(json['score']),
|
|
couleur: serializer.fromJson<String>(json['couleur']),
|
|
ordre: serializer.fromJson<int>(json['ordre']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'prenom': serializer.toJson<String>(prenom),
|
|
'dateNaissance': serializer.toJson<String?>(dateNaissance),
|
|
'score': serializer.toJson<int>(score),
|
|
'couleur': serializer.toJson<String>(couleur),
|
|
'ordre': serializer.toJson<int>(ordre),
|
|
};
|
|
}
|
|
|
|
Enfant copyWith({
|
|
int? id,
|
|
String? prenom,
|
|
Value<String?> dateNaissance = const Value.absent(),
|
|
int? score,
|
|
String? couleur,
|
|
int? ordre,
|
|
}) => Enfant(
|
|
id: id ?? this.id,
|
|
prenom: prenom ?? this.prenom,
|
|
dateNaissance: dateNaissance.present
|
|
? dateNaissance.value
|
|
: this.dateNaissance,
|
|
score: score ?? this.score,
|
|
couleur: couleur ?? this.couleur,
|
|
ordre: ordre ?? this.ordre,
|
|
);
|
|
Enfant copyWithCompanion(EnfantsCompanion data) {
|
|
return Enfant(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
prenom: data.prenom.present ? data.prenom.value : this.prenom,
|
|
dateNaissance: data.dateNaissance.present
|
|
? data.dateNaissance.value
|
|
: this.dateNaissance,
|
|
score: data.score.present ? data.score.value : this.score,
|
|
couleur: data.couleur.present ? data.couleur.value : this.couleur,
|
|
ordre: data.ordre.present ? data.ordre.value : this.ordre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Enfant(')
|
|
..write('id: $id, ')
|
|
..write('prenom: $prenom, ')
|
|
..write('dateNaissance: $dateNaissance, ')
|
|
..write('score: $score, ')
|
|
..write('couleur: $couleur, ')
|
|
..write('ordre: $ordre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
Object.hash(id, prenom, dateNaissance, score, couleur, ordre);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Enfant &&
|
|
other.id == this.id &&
|
|
other.prenom == this.prenom &&
|
|
other.dateNaissance == this.dateNaissance &&
|
|
other.score == this.score &&
|
|
other.couleur == this.couleur &&
|
|
other.ordre == this.ordre);
|
|
}
|
|
|
|
class EnfantsCompanion extends UpdateCompanion<Enfant> {
|
|
final Value<int> id;
|
|
final Value<String> prenom;
|
|
final Value<String?> dateNaissance;
|
|
final Value<int> score;
|
|
final Value<String> couleur;
|
|
final Value<int> ordre;
|
|
const EnfantsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.prenom = const Value.absent(),
|
|
this.dateNaissance = const Value.absent(),
|
|
this.score = const Value.absent(),
|
|
this.couleur = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
});
|
|
EnfantsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String prenom,
|
|
this.dateNaissance = const Value.absent(),
|
|
this.score = const Value.absent(),
|
|
this.couleur = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
}) : prenom = Value(prenom);
|
|
static Insertable<Enfant> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? prenom,
|
|
Expression<String>? dateNaissance,
|
|
Expression<int>? score,
|
|
Expression<String>? couleur,
|
|
Expression<int>? ordre,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (prenom != null) 'prenom': prenom,
|
|
if (dateNaissance != null) 'date_naissance': dateNaissance,
|
|
if (score != null) 'score': score,
|
|
if (couleur != null) 'couleur': couleur,
|
|
if (ordre != null) 'ordre': ordre,
|
|
});
|
|
}
|
|
|
|
EnfantsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? prenom,
|
|
Value<String?>? dateNaissance,
|
|
Value<int>? score,
|
|
Value<String>? couleur,
|
|
Value<int>? ordre,
|
|
}) {
|
|
return EnfantsCompanion(
|
|
id: id ?? this.id,
|
|
prenom: prenom ?? this.prenom,
|
|
dateNaissance: dateNaissance ?? this.dateNaissance,
|
|
score: score ?? this.score,
|
|
couleur: couleur ?? this.couleur,
|
|
ordre: ordre ?? this.ordre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (prenom.present) {
|
|
map['prenom'] = Variable<String>(prenom.value);
|
|
}
|
|
if (dateNaissance.present) {
|
|
map['date_naissance'] = Variable<String>(dateNaissance.value);
|
|
}
|
|
if (score.present) {
|
|
map['score'] = Variable<int>(score.value);
|
|
}
|
|
if (couleur.present) {
|
|
map['couleur'] = Variable<String>(couleur.value);
|
|
}
|
|
if (ordre.present) {
|
|
map['ordre'] = Variable<int>(ordre.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('EnfantsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('prenom: $prenom, ')
|
|
..write('dateNaissance: $dateNaissance, ')
|
|
..write('score: $score, ')
|
|
..write('couleur: $couleur, ')
|
|
..write('ordre: $ordre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ReglesTable extends Regles with TableInfo<$ReglesTable, Regle> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ReglesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _libelleMeta = const VerificationMeta(
|
|
'libelle',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> libelle = GeneratedColumn<String>(
|
|
'libelle',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _pointsMeta = const VerificationMeta('points');
|
|
@override
|
|
late final GeneratedColumn<int> points = GeneratedColumn<int>(
|
|
'points',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _iconeMeta = const VerificationMeta('icone');
|
|
@override
|
|
late final GeneratedColumn<String> icone = GeneratedColumn<String>(
|
|
'icone',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('⭐'),
|
|
);
|
|
static const VerificationMeta _actifMeta = const VerificationMeta('actif');
|
|
@override
|
|
late final GeneratedColumn<bool> actif = GeneratedColumn<bool>(
|
|
'actif',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("actif" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(true),
|
|
);
|
|
static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
|
|
@override
|
|
late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
|
|
'ordre',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
static const VerificationMeta _familleMeta = const VerificationMeta(
|
|
'famille',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> famille = GeneratedColumn<String>(
|
|
'famille',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('📋 Autre'),
|
|
);
|
|
static const VerificationMeta _familleOrdreMeta = const VerificationMeta(
|
|
'familleOrdre',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> familleOrdre = GeneratedColumn<int>(
|
|
'famille_ordre',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(99),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
libelle,
|
|
points,
|
|
icone,
|
|
actif,
|
|
ordre,
|
|
famille,
|
|
familleOrdre,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'regles';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Regle> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('libelle')) {
|
|
context.handle(
|
|
_libelleMeta,
|
|
libelle.isAcceptableOrUnknown(data['libelle']!, _libelleMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_libelleMeta);
|
|
}
|
|
if (data.containsKey('points')) {
|
|
context.handle(
|
|
_pointsMeta,
|
|
points.isAcceptableOrUnknown(data['points']!, _pointsMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_pointsMeta);
|
|
}
|
|
if (data.containsKey('icone')) {
|
|
context.handle(
|
|
_iconeMeta,
|
|
icone.isAcceptableOrUnknown(data['icone']!, _iconeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('actif')) {
|
|
context.handle(
|
|
_actifMeta,
|
|
actif.isAcceptableOrUnknown(data['actif']!, _actifMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('ordre')) {
|
|
context.handle(
|
|
_ordreMeta,
|
|
ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('famille')) {
|
|
context.handle(
|
|
_familleMeta,
|
|
famille.isAcceptableOrUnknown(data['famille']!, _familleMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('famille_ordre')) {
|
|
context.handle(
|
|
_familleOrdreMeta,
|
|
familleOrdre.isAcceptableOrUnknown(
|
|
data['famille_ordre']!,
|
|
_familleOrdreMeta,
|
|
),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Regle map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Regle(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
libelle: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}libelle'],
|
|
)!,
|
|
points: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}points'],
|
|
)!,
|
|
icone: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}icone'],
|
|
)!,
|
|
actif: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}actif'],
|
|
)!,
|
|
ordre: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}ordre'],
|
|
)!,
|
|
famille: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}famille'],
|
|
)!,
|
|
familleOrdre: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}famille_ordre'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ReglesTable createAlias(String alias) {
|
|
return $ReglesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Regle extends DataClass implements Insertable<Regle> {
|
|
final int id;
|
|
final String libelle;
|
|
final int points;
|
|
final String icone;
|
|
final bool actif;
|
|
final int ordre;
|
|
final String famille;
|
|
final int familleOrdre;
|
|
const Regle({
|
|
required this.id,
|
|
required this.libelle,
|
|
required this.points,
|
|
required this.icone,
|
|
required this.actif,
|
|
required this.ordre,
|
|
required this.famille,
|
|
required this.familleOrdre,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['libelle'] = Variable<String>(libelle);
|
|
map['points'] = Variable<int>(points);
|
|
map['icone'] = Variable<String>(icone);
|
|
map['actif'] = Variable<bool>(actif);
|
|
map['ordre'] = Variable<int>(ordre);
|
|
map['famille'] = Variable<String>(famille);
|
|
map['famille_ordre'] = Variable<int>(familleOrdre);
|
|
return map;
|
|
}
|
|
|
|
ReglesCompanion toCompanion(bool nullToAbsent) {
|
|
return ReglesCompanion(
|
|
id: Value(id),
|
|
libelle: Value(libelle),
|
|
points: Value(points),
|
|
icone: Value(icone),
|
|
actif: Value(actif),
|
|
ordre: Value(ordre),
|
|
famille: Value(famille),
|
|
familleOrdre: Value(familleOrdre),
|
|
);
|
|
}
|
|
|
|
factory Regle.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Regle(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
libelle: serializer.fromJson<String>(json['libelle']),
|
|
points: serializer.fromJson<int>(json['points']),
|
|
icone: serializer.fromJson<String>(json['icone']),
|
|
actif: serializer.fromJson<bool>(json['actif']),
|
|
ordre: serializer.fromJson<int>(json['ordre']),
|
|
famille: serializer.fromJson<String>(json['famille']),
|
|
familleOrdre: serializer.fromJson<int>(json['familleOrdre']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'libelle': serializer.toJson<String>(libelle),
|
|
'points': serializer.toJson<int>(points),
|
|
'icone': serializer.toJson<String>(icone),
|
|
'actif': serializer.toJson<bool>(actif),
|
|
'ordre': serializer.toJson<int>(ordre),
|
|
'famille': serializer.toJson<String>(famille),
|
|
'familleOrdre': serializer.toJson<int>(familleOrdre),
|
|
};
|
|
}
|
|
|
|
Regle copyWith({
|
|
int? id,
|
|
String? libelle,
|
|
int? points,
|
|
String? icone,
|
|
bool? actif,
|
|
int? ordre,
|
|
String? famille,
|
|
int? familleOrdre,
|
|
}) => Regle(
|
|
id: id ?? this.id,
|
|
libelle: libelle ?? this.libelle,
|
|
points: points ?? this.points,
|
|
icone: icone ?? this.icone,
|
|
actif: actif ?? this.actif,
|
|
ordre: ordre ?? this.ordre,
|
|
famille: famille ?? this.famille,
|
|
familleOrdre: familleOrdre ?? this.familleOrdre,
|
|
);
|
|
Regle copyWithCompanion(ReglesCompanion data) {
|
|
return Regle(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
libelle: data.libelle.present ? data.libelle.value : this.libelle,
|
|
points: data.points.present ? data.points.value : this.points,
|
|
icone: data.icone.present ? data.icone.value : this.icone,
|
|
actif: data.actif.present ? data.actif.value : this.actif,
|
|
ordre: data.ordre.present ? data.ordre.value : this.ordre,
|
|
famille: data.famille.present ? data.famille.value : this.famille,
|
|
familleOrdre: data.familleOrdre.present
|
|
? data.familleOrdre.value
|
|
: this.familleOrdre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Regle(')
|
|
..write('id: $id, ')
|
|
..write('libelle: $libelle, ')
|
|
..write('points: $points, ')
|
|
..write('icone: $icone, ')
|
|
..write('actif: $actif, ')
|
|
..write('ordre: $ordre, ')
|
|
..write('famille: $famille, ')
|
|
..write('familleOrdre: $familleOrdre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
libelle,
|
|
points,
|
|
icone,
|
|
actif,
|
|
ordre,
|
|
famille,
|
|
familleOrdre,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Regle &&
|
|
other.id == this.id &&
|
|
other.libelle == this.libelle &&
|
|
other.points == this.points &&
|
|
other.icone == this.icone &&
|
|
other.actif == this.actif &&
|
|
other.ordre == this.ordre &&
|
|
other.famille == this.famille &&
|
|
other.familleOrdre == this.familleOrdre);
|
|
}
|
|
|
|
class ReglesCompanion extends UpdateCompanion<Regle> {
|
|
final Value<int> id;
|
|
final Value<String> libelle;
|
|
final Value<int> points;
|
|
final Value<String> icone;
|
|
final Value<bool> actif;
|
|
final Value<int> ordre;
|
|
final Value<String> famille;
|
|
final Value<int> familleOrdre;
|
|
const ReglesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.libelle = const Value.absent(),
|
|
this.points = const Value.absent(),
|
|
this.icone = const Value.absent(),
|
|
this.actif = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
this.famille = const Value.absent(),
|
|
this.familleOrdre = const Value.absent(),
|
|
});
|
|
ReglesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String libelle,
|
|
required int points,
|
|
this.icone = const Value.absent(),
|
|
this.actif = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
this.famille = const Value.absent(),
|
|
this.familleOrdre = const Value.absent(),
|
|
}) : libelle = Value(libelle),
|
|
points = Value(points);
|
|
static Insertable<Regle> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? libelle,
|
|
Expression<int>? points,
|
|
Expression<String>? icone,
|
|
Expression<bool>? actif,
|
|
Expression<int>? ordre,
|
|
Expression<String>? famille,
|
|
Expression<int>? familleOrdre,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (libelle != null) 'libelle': libelle,
|
|
if (points != null) 'points': points,
|
|
if (icone != null) 'icone': icone,
|
|
if (actif != null) 'actif': actif,
|
|
if (ordre != null) 'ordre': ordre,
|
|
if (famille != null) 'famille': famille,
|
|
if (familleOrdre != null) 'famille_ordre': familleOrdre,
|
|
});
|
|
}
|
|
|
|
ReglesCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? libelle,
|
|
Value<int>? points,
|
|
Value<String>? icone,
|
|
Value<bool>? actif,
|
|
Value<int>? ordre,
|
|
Value<String>? famille,
|
|
Value<int>? familleOrdre,
|
|
}) {
|
|
return ReglesCompanion(
|
|
id: id ?? this.id,
|
|
libelle: libelle ?? this.libelle,
|
|
points: points ?? this.points,
|
|
icone: icone ?? this.icone,
|
|
actif: actif ?? this.actif,
|
|
ordre: ordre ?? this.ordre,
|
|
famille: famille ?? this.famille,
|
|
familleOrdre: familleOrdre ?? this.familleOrdre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (libelle.present) {
|
|
map['libelle'] = Variable<String>(libelle.value);
|
|
}
|
|
if (points.present) {
|
|
map['points'] = Variable<int>(points.value);
|
|
}
|
|
if (icone.present) {
|
|
map['icone'] = Variable<String>(icone.value);
|
|
}
|
|
if (actif.present) {
|
|
map['actif'] = Variable<bool>(actif.value);
|
|
}
|
|
if (ordre.present) {
|
|
map['ordre'] = Variable<int>(ordre.value);
|
|
}
|
|
if (famille.present) {
|
|
map['famille'] = Variable<String>(famille.value);
|
|
}
|
|
if (familleOrdre.present) {
|
|
map['famille_ordre'] = Variable<int>(familleOrdre.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ReglesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('libelle: $libelle, ')
|
|
..write('points: $points, ')
|
|
..write('icone: $icone, ')
|
|
..write('actif: $actif, ')
|
|
..write('ordre: $ordre, ')
|
|
..write('famille: $famille, ')
|
|
..write('familleOrdre: $familleOrdre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $RecompensesTable extends Recompenses
|
|
with TableInfo<$RecompensesTable, Recompense> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$RecompensesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _libelleMeta = const VerificationMeta(
|
|
'libelle',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<String> libelle = GeneratedColumn<String>(
|
|
'libelle',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _coutPointsMeta = const VerificationMeta(
|
|
'coutPoints',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> coutPoints = GeneratedColumn<int>(
|
|
'cout_points',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _iconeMeta = const VerificationMeta('icone');
|
|
@override
|
|
late final GeneratedColumn<String> icone = GeneratedColumn<String>(
|
|
'icone',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant('🎁'),
|
|
);
|
|
static const VerificationMeta _actifMeta = const VerificationMeta('actif');
|
|
@override
|
|
late final GeneratedColumn<bool> actif = GeneratedColumn<bool>(
|
|
'actif',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("actif" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(true),
|
|
);
|
|
static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
|
|
@override
|
|
late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
|
|
'ordre',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultValue: const Constant(0),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
libelle,
|
|
coutPoints,
|
|
icone,
|
|
actif,
|
|
ordre,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'recompenses';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Recompense> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('libelle')) {
|
|
context.handle(
|
|
_libelleMeta,
|
|
libelle.isAcceptableOrUnknown(data['libelle']!, _libelleMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_libelleMeta);
|
|
}
|
|
if (data.containsKey('cout_points')) {
|
|
context.handle(
|
|
_coutPointsMeta,
|
|
coutPoints.isAcceptableOrUnknown(data['cout_points']!, _coutPointsMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_coutPointsMeta);
|
|
}
|
|
if (data.containsKey('icone')) {
|
|
context.handle(
|
|
_iconeMeta,
|
|
icone.isAcceptableOrUnknown(data['icone']!, _iconeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('actif')) {
|
|
context.handle(
|
|
_actifMeta,
|
|
actif.isAcceptableOrUnknown(data['actif']!, _actifMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('ordre')) {
|
|
context.handle(
|
|
_ordreMeta,
|
|
ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Recompense map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Recompense(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
libelle: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}libelle'],
|
|
)!,
|
|
coutPoints: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}cout_points'],
|
|
)!,
|
|
icone: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}icone'],
|
|
)!,
|
|
actif: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}actif'],
|
|
)!,
|
|
ordre: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}ordre'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$RecompensesTable createAlias(String alias) {
|
|
return $RecompensesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Recompense extends DataClass implements Insertable<Recompense> {
|
|
final int id;
|
|
final String libelle;
|
|
final int coutPoints;
|
|
final String icone;
|
|
final bool actif;
|
|
final int ordre;
|
|
const Recompense({
|
|
required this.id,
|
|
required this.libelle,
|
|
required this.coutPoints,
|
|
required this.icone,
|
|
required this.actif,
|
|
required this.ordre,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['libelle'] = Variable<String>(libelle);
|
|
map['cout_points'] = Variable<int>(coutPoints);
|
|
map['icone'] = Variable<String>(icone);
|
|
map['actif'] = Variable<bool>(actif);
|
|
map['ordre'] = Variable<int>(ordre);
|
|
return map;
|
|
}
|
|
|
|
RecompensesCompanion toCompanion(bool nullToAbsent) {
|
|
return RecompensesCompanion(
|
|
id: Value(id),
|
|
libelle: Value(libelle),
|
|
coutPoints: Value(coutPoints),
|
|
icone: Value(icone),
|
|
actif: Value(actif),
|
|
ordre: Value(ordre),
|
|
);
|
|
}
|
|
|
|
factory Recompense.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Recompense(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
libelle: serializer.fromJson<String>(json['libelle']),
|
|
coutPoints: serializer.fromJson<int>(json['coutPoints']),
|
|
icone: serializer.fromJson<String>(json['icone']),
|
|
actif: serializer.fromJson<bool>(json['actif']),
|
|
ordre: serializer.fromJson<int>(json['ordre']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'libelle': serializer.toJson<String>(libelle),
|
|
'coutPoints': serializer.toJson<int>(coutPoints),
|
|
'icone': serializer.toJson<String>(icone),
|
|
'actif': serializer.toJson<bool>(actif),
|
|
'ordre': serializer.toJson<int>(ordre),
|
|
};
|
|
}
|
|
|
|
Recompense copyWith({
|
|
int? id,
|
|
String? libelle,
|
|
int? coutPoints,
|
|
String? icone,
|
|
bool? actif,
|
|
int? ordre,
|
|
}) => Recompense(
|
|
id: id ?? this.id,
|
|
libelle: libelle ?? this.libelle,
|
|
coutPoints: coutPoints ?? this.coutPoints,
|
|
icone: icone ?? this.icone,
|
|
actif: actif ?? this.actif,
|
|
ordre: ordre ?? this.ordre,
|
|
);
|
|
Recompense copyWithCompanion(RecompensesCompanion data) {
|
|
return Recompense(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
libelle: data.libelle.present ? data.libelle.value : this.libelle,
|
|
coutPoints: data.coutPoints.present
|
|
? data.coutPoints.value
|
|
: this.coutPoints,
|
|
icone: data.icone.present ? data.icone.value : this.icone,
|
|
actif: data.actif.present ? data.actif.value : this.actif,
|
|
ordre: data.ordre.present ? data.ordre.value : this.ordre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Recompense(')
|
|
..write('id: $id, ')
|
|
..write('libelle: $libelle, ')
|
|
..write('coutPoints: $coutPoints, ')
|
|
..write('icone: $icone, ')
|
|
..write('actif: $actif, ')
|
|
..write('ordre: $ordre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, libelle, coutPoints, icone, actif, ordre);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Recompense &&
|
|
other.id == this.id &&
|
|
other.libelle == this.libelle &&
|
|
other.coutPoints == this.coutPoints &&
|
|
other.icone == this.icone &&
|
|
other.actif == this.actif &&
|
|
other.ordre == this.ordre);
|
|
}
|
|
|
|
class RecompensesCompanion extends UpdateCompanion<Recompense> {
|
|
final Value<int> id;
|
|
final Value<String> libelle;
|
|
final Value<int> coutPoints;
|
|
final Value<String> icone;
|
|
final Value<bool> actif;
|
|
final Value<int> ordre;
|
|
const RecompensesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.libelle = const Value.absent(),
|
|
this.coutPoints = const Value.absent(),
|
|
this.icone = const Value.absent(),
|
|
this.actif = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
});
|
|
RecompensesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String libelle,
|
|
required int coutPoints,
|
|
this.icone = const Value.absent(),
|
|
this.actif = const Value.absent(),
|
|
this.ordre = const Value.absent(),
|
|
}) : libelle = Value(libelle),
|
|
coutPoints = Value(coutPoints);
|
|
static Insertable<Recompense> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? libelle,
|
|
Expression<int>? coutPoints,
|
|
Expression<String>? icone,
|
|
Expression<bool>? actif,
|
|
Expression<int>? ordre,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (libelle != null) 'libelle': libelle,
|
|
if (coutPoints != null) 'cout_points': coutPoints,
|
|
if (icone != null) 'icone': icone,
|
|
if (actif != null) 'actif': actif,
|
|
if (ordre != null) 'ordre': ordre,
|
|
});
|
|
}
|
|
|
|
RecompensesCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<String>? libelle,
|
|
Value<int>? coutPoints,
|
|
Value<String>? icone,
|
|
Value<bool>? actif,
|
|
Value<int>? ordre,
|
|
}) {
|
|
return RecompensesCompanion(
|
|
id: id ?? this.id,
|
|
libelle: libelle ?? this.libelle,
|
|
coutPoints: coutPoints ?? this.coutPoints,
|
|
icone: icone ?? this.icone,
|
|
actif: actif ?? this.actif,
|
|
ordre: ordre ?? this.ordre,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (libelle.present) {
|
|
map['libelle'] = Variable<String>(libelle.value);
|
|
}
|
|
if (coutPoints.present) {
|
|
map['cout_points'] = Variable<int>(coutPoints.value);
|
|
}
|
|
if (icone.present) {
|
|
map['icone'] = Variable<String>(icone.value);
|
|
}
|
|
if (actif.present) {
|
|
map['actif'] = Variable<bool>(actif.value);
|
|
}
|
|
if (ordre.present) {
|
|
map['ordre'] = Variable<int>(ordre.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('RecompensesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('libelle: $libelle, ')
|
|
..write('coutPoints: $coutPoints, ')
|
|
..write('icone: $icone, ')
|
|
..write('actif: $actif, ')
|
|
..write('ordre: $ordre')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $MouvementsTable extends Mouvements
|
|
with TableInfo<$MouvementsTable, Mouvement> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$MouvementsTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id',
|
|
aliasedName,
|
|
false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'PRIMARY KEY AUTOINCREMENT',
|
|
),
|
|
);
|
|
static const VerificationMeta _enfantIdMeta = const VerificationMeta(
|
|
'enfantId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> enfantId = GeneratedColumn<int>(
|
|
'enfant_id',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES enfants (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _regleIdMeta = const VerificationMeta(
|
|
'regleId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> regleId = GeneratedColumn<int>(
|
|
'regle_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES regles (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _recompenseIdMeta = const VerificationMeta(
|
|
'recompenseId',
|
|
);
|
|
@override
|
|
late final GeneratedColumn<int> recompenseId = GeneratedColumn<int>(
|
|
'recompense_id',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'REFERENCES recompenses (id)',
|
|
),
|
|
);
|
|
static const VerificationMeta _deltaMeta = const VerificationMeta('delta');
|
|
@override
|
|
late final GeneratedColumn<int> delta = GeneratedColumn<int>(
|
|
'delta',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _noteMeta = const VerificationMeta('note');
|
|
@override
|
|
late final GeneratedColumn<String> note = GeneratedColumn<String>(
|
|
'note',
|
|
aliasedName,
|
|
true,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: false,
|
|
);
|
|
static const VerificationMeta _creeLeMeta = const VerificationMeta('creeLe');
|
|
@override
|
|
late final GeneratedColumn<DateTime> creeLe = GeneratedColumn<DateTime>(
|
|
'cree_le',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime,
|
|
);
|
|
static const VerificationMeta _annuleMeta = const VerificationMeta('annule');
|
|
@override
|
|
late final GeneratedColumn<bool> annule = GeneratedColumn<bool>(
|
|
'annule',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.bool,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints: GeneratedColumn.constraintIsAlways(
|
|
'CHECK ("annule" IN (0, 1))',
|
|
),
|
|
defaultValue: const Constant(false),
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
enfantId,
|
|
regleId,
|
|
recompenseId,
|
|
delta,
|
|
note,
|
|
creeLe,
|
|
annule,
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'mouvements';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<Mouvement> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('enfant_id')) {
|
|
context.handle(
|
|
_enfantIdMeta,
|
|
enfantId.isAcceptableOrUnknown(data['enfant_id']!, _enfantIdMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_enfantIdMeta);
|
|
}
|
|
if (data.containsKey('regle_id')) {
|
|
context.handle(
|
|
_regleIdMeta,
|
|
regleId.isAcceptableOrUnknown(data['regle_id']!, _regleIdMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('recompense_id')) {
|
|
context.handle(
|
|
_recompenseIdMeta,
|
|
recompenseId.isAcceptableOrUnknown(
|
|
data['recompense_id']!,
|
|
_recompenseIdMeta,
|
|
),
|
|
);
|
|
}
|
|
if (data.containsKey('delta')) {
|
|
context.handle(
|
|
_deltaMeta,
|
|
delta.isAcceptableOrUnknown(data['delta']!, _deltaMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_deltaMeta);
|
|
}
|
|
if (data.containsKey('note')) {
|
|
context.handle(
|
|
_noteMeta,
|
|
note.isAcceptableOrUnknown(data['note']!, _noteMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('cree_le')) {
|
|
context.handle(
|
|
_creeLeMeta,
|
|
creeLe.isAcceptableOrUnknown(data['cree_le']!, _creeLeMeta),
|
|
);
|
|
}
|
|
if (data.containsKey('annule')) {
|
|
context.handle(
|
|
_annuleMeta,
|
|
annule.isAcceptableOrUnknown(data['annule']!, _annuleMeta),
|
|
);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Mouvement map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return Mouvement(
|
|
id: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}id'],
|
|
)!,
|
|
enfantId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}enfant_id'],
|
|
)!,
|
|
regleId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}regle_id'],
|
|
),
|
|
recompenseId: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}recompense_id'],
|
|
),
|
|
delta: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.int,
|
|
data['${effectivePrefix}delta'],
|
|
)!,
|
|
note: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}note'],
|
|
),
|
|
creeLe: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime,
|
|
data['${effectivePrefix}cree_le'],
|
|
)!,
|
|
annule: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.bool,
|
|
data['${effectivePrefix}annule'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$MouvementsTable createAlias(String alias) {
|
|
return $MouvementsTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class Mouvement extends DataClass implements Insertable<Mouvement> {
|
|
final int id;
|
|
final int enfantId;
|
|
final int? regleId;
|
|
final int? recompenseId;
|
|
final int delta;
|
|
final String? note;
|
|
final DateTime creeLe;
|
|
final bool annule;
|
|
const Mouvement({
|
|
required this.id,
|
|
required this.enfantId,
|
|
this.regleId,
|
|
this.recompenseId,
|
|
required this.delta,
|
|
this.note,
|
|
required this.creeLe,
|
|
required this.annule,
|
|
});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['enfant_id'] = Variable<int>(enfantId);
|
|
if (!nullToAbsent || regleId != null) {
|
|
map['regle_id'] = Variable<int>(regleId);
|
|
}
|
|
if (!nullToAbsent || recompenseId != null) {
|
|
map['recompense_id'] = Variable<int>(recompenseId);
|
|
}
|
|
map['delta'] = Variable<int>(delta);
|
|
if (!nullToAbsent || note != null) {
|
|
map['note'] = Variable<String>(note);
|
|
}
|
|
map['cree_le'] = Variable<DateTime>(creeLe);
|
|
map['annule'] = Variable<bool>(annule);
|
|
return map;
|
|
}
|
|
|
|
MouvementsCompanion toCompanion(bool nullToAbsent) {
|
|
return MouvementsCompanion(
|
|
id: Value(id),
|
|
enfantId: Value(enfantId),
|
|
regleId: regleId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(regleId),
|
|
recompenseId: recompenseId == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(recompenseId),
|
|
delta: Value(delta),
|
|
note: note == null && nullToAbsent ? const Value.absent() : Value(note),
|
|
creeLe: Value(creeLe),
|
|
annule: Value(annule),
|
|
);
|
|
}
|
|
|
|
factory Mouvement.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return Mouvement(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
enfantId: serializer.fromJson<int>(json['enfantId']),
|
|
regleId: serializer.fromJson<int?>(json['regleId']),
|
|
recompenseId: serializer.fromJson<int?>(json['recompenseId']),
|
|
delta: serializer.fromJson<int>(json['delta']),
|
|
note: serializer.fromJson<String?>(json['note']),
|
|
creeLe: serializer.fromJson<DateTime>(json['creeLe']),
|
|
annule: serializer.fromJson<bool>(json['annule']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'enfantId': serializer.toJson<int>(enfantId),
|
|
'regleId': serializer.toJson<int?>(regleId),
|
|
'recompenseId': serializer.toJson<int?>(recompenseId),
|
|
'delta': serializer.toJson<int>(delta),
|
|
'note': serializer.toJson<String?>(note),
|
|
'creeLe': serializer.toJson<DateTime>(creeLe),
|
|
'annule': serializer.toJson<bool>(annule),
|
|
};
|
|
}
|
|
|
|
Mouvement copyWith({
|
|
int? id,
|
|
int? enfantId,
|
|
Value<int?> regleId = const Value.absent(),
|
|
Value<int?> recompenseId = const Value.absent(),
|
|
int? delta,
|
|
Value<String?> note = const Value.absent(),
|
|
DateTime? creeLe,
|
|
bool? annule,
|
|
}) => Mouvement(
|
|
id: id ?? this.id,
|
|
enfantId: enfantId ?? this.enfantId,
|
|
regleId: regleId.present ? regleId.value : this.regleId,
|
|
recompenseId: recompenseId.present ? recompenseId.value : this.recompenseId,
|
|
delta: delta ?? this.delta,
|
|
note: note.present ? note.value : this.note,
|
|
creeLe: creeLe ?? this.creeLe,
|
|
annule: annule ?? this.annule,
|
|
);
|
|
Mouvement copyWithCompanion(MouvementsCompanion data) {
|
|
return Mouvement(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
enfantId: data.enfantId.present ? data.enfantId.value : this.enfantId,
|
|
regleId: data.regleId.present ? data.regleId.value : this.regleId,
|
|
recompenseId: data.recompenseId.present
|
|
? data.recompenseId.value
|
|
: this.recompenseId,
|
|
delta: data.delta.present ? data.delta.value : this.delta,
|
|
note: data.note.present ? data.note.value : this.note,
|
|
creeLe: data.creeLe.present ? data.creeLe.value : this.creeLe,
|
|
annule: data.annule.present ? data.annule.value : this.annule,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Mouvement(')
|
|
..write('id: $id, ')
|
|
..write('enfantId: $enfantId, ')
|
|
..write('regleId: $regleId, ')
|
|
..write('recompenseId: $recompenseId, ')
|
|
..write('delta: $delta, ')
|
|
..write('note: $note, ')
|
|
..write('creeLe: $creeLe, ')
|
|
..write('annule: $annule')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id,
|
|
enfantId,
|
|
regleId,
|
|
recompenseId,
|
|
delta,
|
|
note,
|
|
creeLe,
|
|
annule,
|
|
);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is Mouvement &&
|
|
other.id == this.id &&
|
|
other.enfantId == this.enfantId &&
|
|
other.regleId == this.regleId &&
|
|
other.recompenseId == this.recompenseId &&
|
|
other.delta == this.delta &&
|
|
other.note == this.note &&
|
|
other.creeLe == this.creeLe &&
|
|
other.annule == this.annule);
|
|
}
|
|
|
|
class MouvementsCompanion extends UpdateCompanion<Mouvement> {
|
|
final Value<int> id;
|
|
final Value<int> enfantId;
|
|
final Value<int?> regleId;
|
|
final Value<int?> recompenseId;
|
|
final Value<int> delta;
|
|
final Value<String?> note;
|
|
final Value<DateTime> creeLe;
|
|
final Value<bool> annule;
|
|
const MouvementsCompanion({
|
|
this.id = const Value.absent(),
|
|
this.enfantId = const Value.absent(),
|
|
this.regleId = const Value.absent(),
|
|
this.recompenseId = const Value.absent(),
|
|
this.delta = const Value.absent(),
|
|
this.note = const Value.absent(),
|
|
this.creeLe = const Value.absent(),
|
|
this.annule = const Value.absent(),
|
|
});
|
|
MouvementsCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required int enfantId,
|
|
this.regleId = const Value.absent(),
|
|
this.recompenseId = const Value.absent(),
|
|
required int delta,
|
|
this.note = const Value.absent(),
|
|
this.creeLe = const Value.absent(),
|
|
this.annule = const Value.absent(),
|
|
}) : enfantId = Value(enfantId),
|
|
delta = Value(delta);
|
|
static Insertable<Mouvement> custom({
|
|
Expression<int>? id,
|
|
Expression<int>? enfantId,
|
|
Expression<int>? regleId,
|
|
Expression<int>? recompenseId,
|
|
Expression<int>? delta,
|
|
Expression<String>? note,
|
|
Expression<DateTime>? creeLe,
|
|
Expression<bool>? annule,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (enfantId != null) 'enfant_id': enfantId,
|
|
if (regleId != null) 'regle_id': regleId,
|
|
if (recompenseId != null) 'recompense_id': recompenseId,
|
|
if (delta != null) 'delta': delta,
|
|
if (note != null) 'note': note,
|
|
if (creeLe != null) 'cree_le': creeLe,
|
|
if (annule != null) 'annule': annule,
|
|
});
|
|
}
|
|
|
|
MouvementsCompanion copyWith({
|
|
Value<int>? id,
|
|
Value<int>? enfantId,
|
|
Value<int?>? regleId,
|
|
Value<int?>? recompenseId,
|
|
Value<int>? delta,
|
|
Value<String?>? note,
|
|
Value<DateTime>? creeLe,
|
|
Value<bool>? annule,
|
|
}) {
|
|
return MouvementsCompanion(
|
|
id: id ?? this.id,
|
|
enfantId: enfantId ?? this.enfantId,
|
|
regleId: regleId ?? this.regleId,
|
|
recompenseId: recompenseId ?? this.recompenseId,
|
|
delta: delta ?? this.delta,
|
|
note: note ?? this.note,
|
|
creeLe: creeLe ?? this.creeLe,
|
|
annule: annule ?? this.annule,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (enfantId.present) {
|
|
map['enfant_id'] = Variable<int>(enfantId.value);
|
|
}
|
|
if (regleId.present) {
|
|
map['regle_id'] = Variable<int>(regleId.value);
|
|
}
|
|
if (recompenseId.present) {
|
|
map['recompense_id'] = Variable<int>(recompenseId.value);
|
|
}
|
|
if (delta.present) {
|
|
map['delta'] = Variable<int>(delta.value);
|
|
}
|
|
if (note.present) {
|
|
map['note'] = Variable<String>(note.value);
|
|
}
|
|
if (creeLe.present) {
|
|
map['cree_le'] = Variable<DateTime>(creeLe.value);
|
|
}
|
|
if (annule.present) {
|
|
map['annule'] = Variable<bool>(annule.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MouvementsCompanion(')
|
|
..write('id: $id, ')
|
|
..write('enfantId: $enfantId, ')
|
|
..write('regleId: $regleId, ')
|
|
..write('recompenseId: $recompenseId, ')
|
|
..write('delta: $delta, ')
|
|
..write('note: $note, ')
|
|
..write('creeLe: $creeLe, ')
|
|
..write('annule: $annule')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
class $ConfigTable extends Config with TableInfo<$ConfigTable, ConfigData> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ConfigTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _cleMeta = const VerificationMeta('cle');
|
|
@override
|
|
late final GeneratedColumn<String> cle = GeneratedColumn<String>(
|
|
'cle',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
static const VerificationMeta _valeurMeta = const VerificationMeta('valeur');
|
|
@override
|
|
late final GeneratedColumn<String> valeur = GeneratedColumn<String>(
|
|
'valeur',
|
|
aliasedName,
|
|
false,
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true,
|
|
);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [cle, valeur];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'config';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<ConfigData> instance, {
|
|
bool isInserting = false,
|
|
}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('cle')) {
|
|
context.handle(
|
|
_cleMeta,
|
|
cle.isAcceptableOrUnknown(data['cle']!, _cleMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_cleMeta);
|
|
}
|
|
if (data.containsKey('valeur')) {
|
|
context.handle(
|
|
_valeurMeta,
|
|
valeur.isAcceptableOrUnknown(data['valeur']!, _valeurMeta),
|
|
);
|
|
} else if (isInserting) {
|
|
context.missing(_valeurMeta);
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {cle};
|
|
@override
|
|
ConfigData map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ConfigData(
|
|
cle: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}cle'],
|
|
)!,
|
|
valeur: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.string,
|
|
data['${effectivePrefix}valeur'],
|
|
)!,
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ConfigTable createAlias(String alias) {
|
|
return $ConfigTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ConfigData extends DataClass implements Insertable<ConfigData> {
|
|
final String cle;
|
|
final String valeur;
|
|
const ConfigData({required this.cle, required this.valeur});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['cle'] = Variable<String>(cle);
|
|
map['valeur'] = Variable<String>(valeur);
|
|
return map;
|
|
}
|
|
|
|
ConfigCompanion toCompanion(bool nullToAbsent) {
|
|
return ConfigCompanion(cle: Value(cle), valeur: Value(valeur));
|
|
}
|
|
|
|
factory ConfigData.fromJson(
|
|
Map<String, dynamic> json, {
|
|
ValueSerializer? serializer,
|
|
}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ConfigData(
|
|
cle: serializer.fromJson<String>(json['cle']),
|
|
valeur: serializer.fromJson<String>(json['valeur']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'cle': serializer.toJson<String>(cle),
|
|
'valeur': serializer.toJson<String>(valeur),
|
|
};
|
|
}
|
|
|
|
ConfigData copyWith({String? cle, String? valeur}) =>
|
|
ConfigData(cle: cle ?? this.cle, valeur: valeur ?? this.valeur);
|
|
ConfigData copyWithCompanion(ConfigCompanion data) {
|
|
return ConfigData(
|
|
cle: data.cle.present ? data.cle.value : this.cle,
|
|
valeur: data.valeur.present ? data.valeur.value : this.valeur,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ConfigData(')
|
|
..write('cle: $cle, ')
|
|
..write('valeur: $valeur')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(cle, valeur);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ConfigData &&
|
|
other.cle == this.cle &&
|
|
other.valeur == this.valeur);
|
|
}
|
|
|
|
class ConfigCompanion extends UpdateCompanion<ConfigData> {
|
|
final Value<String> cle;
|
|
final Value<String> valeur;
|
|
final Value<int> rowid;
|
|
const ConfigCompanion({
|
|
this.cle = const Value.absent(),
|
|
this.valeur = const Value.absent(),
|
|
this.rowid = const Value.absent(),
|
|
});
|
|
ConfigCompanion.insert({
|
|
required String cle,
|
|
required String valeur,
|
|
this.rowid = const Value.absent(),
|
|
}) : cle = Value(cle),
|
|
valeur = Value(valeur);
|
|
static Insertable<ConfigData> custom({
|
|
Expression<String>? cle,
|
|
Expression<String>? valeur,
|
|
Expression<int>? rowid,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (cle != null) 'cle': cle,
|
|
if (valeur != null) 'valeur': valeur,
|
|
if (rowid != null) 'rowid': rowid,
|
|
});
|
|
}
|
|
|
|
ConfigCompanion copyWith({
|
|
Value<String>? cle,
|
|
Value<String>? valeur,
|
|
Value<int>? rowid,
|
|
}) {
|
|
return ConfigCompanion(
|
|
cle: cle ?? this.cle,
|
|
valeur: valeur ?? this.valeur,
|
|
rowid: rowid ?? this.rowid,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (cle.present) {
|
|
map['cle'] = Variable<String>(cle.value);
|
|
}
|
|
if (valeur.present) {
|
|
map['valeur'] = Variable<String>(valeur.value);
|
|
}
|
|
if (rowid.present) {
|
|
map['rowid'] = Variable<int>(rowid.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ConfigCompanion(')
|
|
..write('cle: $cle, ')
|
|
..write('valeur: $valeur, ')
|
|
..write('rowid: $rowid')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $EnfantsTable enfants = $EnfantsTable(this);
|
|
late final $ReglesTable regles = $ReglesTable(this);
|
|
late final $RecompensesTable recompenses = $RecompensesTable(this);
|
|
late final $MouvementsTable mouvements = $MouvementsTable(this);
|
|
late final $ConfigTable config = $ConfigTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [
|
|
enfants,
|
|
regles,
|
|
recompenses,
|
|
mouvements,
|
|
config,
|
|
];
|
|
}
|
|
|
|
typedef $$EnfantsTableCreateCompanionBuilder =
|
|
EnfantsCompanion Function({
|
|
Value<int> id,
|
|
required String prenom,
|
|
Value<String?> dateNaissance,
|
|
Value<int> score,
|
|
Value<String> couleur,
|
|
Value<int> ordre,
|
|
});
|
|
typedef $$EnfantsTableUpdateCompanionBuilder =
|
|
EnfantsCompanion Function({
|
|
Value<int> id,
|
|
Value<String> prenom,
|
|
Value<String?> dateNaissance,
|
|
Value<int> score,
|
|
Value<String> couleur,
|
|
Value<int> ordre,
|
|
});
|
|
|
|
final class $$EnfantsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $EnfantsTable, Enfant> {
|
|
$$EnfantsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
|
|
_mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.mouvements,
|
|
aliasName: 'enfants__id__mouvements__enfant_id',
|
|
);
|
|
|
|
$$MouvementsTableProcessedTableManager get mouvementsRefs {
|
|
final manager = $$MouvementsTableTableManager(
|
|
$_db,
|
|
$_db.mouvements,
|
|
).filter((f) => f.enfantId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$EnfantsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $EnfantsTable> {
|
|
$$EnfantsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get prenom => $composableBuilder(
|
|
column: $table.prenom,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get dateNaissance => $composableBuilder(
|
|
column: $table.dateNaissance,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get couleur => $composableBuilder(
|
|
column: $table.couleur,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> mouvementsRefs(
|
|
Expression<bool> Function($$MouvementsTableFilterComposer f) f,
|
|
) {
|
|
final $$MouvementsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.enfantId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$EnfantsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $EnfantsTable> {
|
|
$$EnfantsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get prenom => $composableBuilder(
|
|
column: $table.prenom,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get dateNaissance => $composableBuilder(
|
|
column: $table.dateNaissance,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get score => $composableBuilder(
|
|
column: $table.score,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get couleur => $composableBuilder(
|
|
column: $table.couleur,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$EnfantsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $EnfantsTable> {
|
|
$$EnfantsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get prenom =>
|
|
$composableBuilder(column: $table.prenom, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get dateNaissance => $composableBuilder(
|
|
column: $table.dateNaissance,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<int> get score =>
|
|
$composableBuilder(column: $table.score, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get couleur =>
|
|
$composableBuilder(column: $table.couleur, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get ordre =>
|
|
$composableBuilder(column: $table.ordre, builder: (column) => column);
|
|
|
|
Expression<T> mouvementsRefs<T extends Object>(
|
|
Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.enfantId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$EnfantsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$EnfantsTable,
|
|
Enfant,
|
|
$$EnfantsTableFilterComposer,
|
|
$$EnfantsTableOrderingComposer,
|
|
$$EnfantsTableAnnotationComposer,
|
|
$$EnfantsTableCreateCompanionBuilder,
|
|
$$EnfantsTableUpdateCompanionBuilder,
|
|
(Enfant, $$EnfantsTableReferences),
|
|
Enfant,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
> {
|
|
$$EnfantsTableTableManager(_$AppDatabase db, $EnfantsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$EnfantsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$EnfantsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$EnfantsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> prenom = const Value.absent(),
|
|
Value<String?> dateNaissance = const Value.absent(),
|
|
Value<int> score = const Value.absent(),
|
|
Value<String> couleur = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
}) => EnfantsCompanion(
|
|
id: id,
|
|
prenom: prenom,
|
|
dateNaissance: dateNaissance,
|
|
score: score,
|
|
couleur: couleur,
|
|
ordre: ordre,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String prenom,
|
|
Value<String?> dateNaissance = const Value.absent(),
|
|
Value<int> score = const Value.absent(),
|
|
Value<String> couleur = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
}) => EnfantsCompanion.insert(
|
|
id: id,
|
|
prenom: prenom,
|
|
dateNaissance: dateNaissance,
|
|
score: score,
|
|
couleur: couleur,
|
|
ordre: ordre,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$EnfantsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({mouvementsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (mouvementsRefs)
|
|
await $_getPrefetchedData<Enfant, $EnfantsTable, Mouvement>(
|
|
currentTable: table,
|
|
referencedTable: $$EnfantsTableReferences
|
|
._mouvementsRefsTable(db),
|
|
managerFromTypedResult: (p0) => $$EnfantsTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).mouvementsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.enfantId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$EnfantsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$EnfantsTable,
|
|
Enfant,
|
|
$$EnfantsTableFilterComposer,
|
|
$$EnfantsTableOrderingComposer,
|
|
$$EnfantsTableAnnotationComposer,
|
|
$$EnfantsTableCreateCompanionBuilder,
|
|
$$EnfantsTableUpdateCompanionBuilder,
|
|
(Enfant, $$EnfantsTableReferences),
|
|
Enfant,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
>;
|
|
typedef $$ReglesTableCreateCompanionBuilder =
|
|
ReglesCompanion Function({
|
|
Value<int> id,
|
|
required String libelle,
|
|
required int points,
|
|
Value<String> icone,
|
|
Value<bool> actif,
|
|
Value<int> ordre,
|
|
Value<String> famille,
|
|
Value<int> familleOrdre,
|
|
});
|
|
typedef $$ReglesTableUpdateCompanionBuilder =
|
|
ReglesCompanion Function({
|
|
Value<int> id,
|
|
Value<String> libelle,
|
|
Value<int> points,
|
|
Value<String> icone,
|
|
Value<bool> actif,
|
|
Value<int> ordre,
|
|
Value<String> famille,
|
|
Value<int> familleOrdre,
|
|
});
|
|
|
|
final class $$ReglesTableReferences
|
|
extends BaseReferences<_$AppDatabase, $ReglesTable, Regle> {
|
|
$$ReglesTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
|
|
_mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.mouvements,
|
|
aliasName: 'regles__id__mouvements__regle_id',
|
|
);
|
|
|
|
$$MouvementsTableProcessedTableManager get mouvementsRefs {
|
|
final manager = $$MouvementsTableTableManager(
|
|
$_db,
|
|
$_db.mouvements,
|
|
).filter((f) => f.regleId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$ReglesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ReglesTable> {
|
|
$$ReglesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get libelle => $composableBuilder(
|
|
column: $table.libelle,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get points => $composableBuilder(
|
|
column: $table.points,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get icone => $composableBuilder(
|
|
column: $table.icone,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get actif => $composableBuilder(
|
|
column: $table.actif,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get famille => $composableBuilder(
|
|
column: $table.famille,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get familleOrdre => $composableBuilder(
|
|
column: $table.familleOrdre,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> mouvementsRefs(
|
|
Expression<bool> Function($$MouvementsTableFilterComposer f) f,
|
|
) {
|
|
final $$MouvementsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.regleId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ReglesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ReglesTable> {
|
|
$$ReglesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get libelle => $composableBuilder(
|
|
column: $table.libelle,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get points => $composableBuilder(
|
|
column: $table.points,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get icone => $composableBuilder(
|
|
column: $table.icone,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get actif => $composableBuilder(
|
|
column: $table.actif,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get famille => $composableBuilder(
|
|
column: $table.famille,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get familleOrdre => $composableBuilder(
|
|
column: $table.familleOrdre,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ReglesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ReglesTable> {
|
|
$$ReglesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get libelle =>
|
|
$composableBuilder(column: $table.libelle, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get points =>
|
|
$composableBuilder(column: $table.points, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get icone =>
|
|
$composableBuilder(column: $table.icone, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get actif =>
|
|
$composableBuilder(column: $table.actif, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get ordre =>
|
|
$composableBuilder(column: $table.ordre, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get famille =>
|
|
$composableBuilder(column: $table.famille, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get familleOrdre => $composableBuilder(
|
|
column: $table.familleOrdre,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
Expression<T> mouvementsRefs<T extends Object>(
|
|
Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.regleId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$ReglesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ReglesTable,
|
|
Regle,
|
|
$$ReglesTableFilterComposer,
|
|
$$ReglesTableOrderingComposer,
|
|
$$ReglesTableAnnotationComposer,
|
|
$$ReglesTableCreateCompanionBuilder,
|
|
$$ReglesTableUpdateCompanionBuilder,
|
|
(Regle, $$ReglesTableReferences),
|
|
Regle,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
> {
|
|
$$ReglesTableTableManager(_$AppDatabase db, $ReglesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ReglesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ReglesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ReglesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> libelle = const Value.absent(),
|
|
Value<int> points = const Value.absent(),
|
|
Value<String> icone = const Value.absent(),
|
|
Value<bool> actif = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
Value<String> famille = const Value.absent(),
|
|
Value<int> familleOrdre = const Value.absent(),
|
|
}) => ReglesCompanion(
|
|
id: id,
|
|
libelle: libelle,
|
|
points: points,
|
|
icone: icone,
|
|
actif: actif,
|
|
ordre: ordre,
|
|
famille: famille,
|
|
familleOrdre: familleOrdre,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String libelle,
|
|
required int points,
|
|
Value<String> icone = const Value.absent(),
|
|
Value<bool> actif = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
Value<String> famille = const Value.absent(),
|
|
Value<int> familleOrdre = const Value.absent(),
|
|
}) => ReglesCompanion.insert(
|
|
id: id,
|
|
libelle: libelle,
|
|
points: points,
|
|
icone: icone,
|
|
actif: actif,
|
|
ordre: ordre,
|
|
famille: famille,
|
|
familleOrdre: familleOrdre,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) =>
|
|
(e.readTable(table), $$ReglesTableReferences(db, table, e)),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({mouvementsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (mouvementsRefs)
|
|
await $_getPrefetchedData<Regle, $ReglesTable, Mouvement>(
|
|
currentTable: table,
|
|
referencedTable: $$ReglesTableReferences
|
|
._mouvementsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$ReglesTableReferences(db, table, p0).mouvementsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where((e) => e.regleId == item.id),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ReglesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ReglesTable,
|
|
Regle,
|
|
$$ReglesTableFilterComposer,
|
|
$$ReglesTableOrderingComposer,
|
|
$$ReglesTableAnnotationComposer,
|
|
$$ReglesTableCreateCompanionBuilder,
|
|
$$ReglesTableUpdateCompanionBuilder,
|
|
(Regle, $$ReglesTableReferences),
|
|
Regle,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
>;
|
|
typedef $$RecompensesTableCreateCompanionBuilder =
|
|
RecompensesCompanion Function({
|
|
Value<int> id,
|
|
required String libelle,
|
|
required int coutPoints,
|
|
Value<String> icone,
|
|
Value<bool> actif,
|
|
Value<int> ordre,
|
|
});
|
|
typedef $$RecompensesTableUpdateCompanionBuilder =
|
|
RecompensesCompanion Function({
|
|
Value<int> id,
|
|
Value<String> libelle,
|
|
Value<int> coutPoints,
|
|
Value<String> icone,
|
|
Value<bool> actif,
|
|
Value<int> ordre,
|
|
});
|
|
|
|
final class $$RecompensesTableReferences
|
|
extends BaseReferences<_$AppDatabase, $RecompensesTable, Recompense> {
|
|
$$RecompensesTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
|
|
_mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
|
|
db.mouvements,
|
|
aliasName: 'recompenses__id__mouvements__recompense_id',
|
|
);
|
|
|
|
$$MouvementsTableProcessedTableManager get mouvementsRefs {
|
|
final manager = $$MouvementsTableTableManager(
|
|
$_db,
|
|
$_db.mouvements,
|
|
).filter((f) => f.recompenseId.id.sqlEquals($_itemColumn<int>('id')!));
|
|
|
|
final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: cache),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$RecompensesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $RecompensesTable> {
|
|
$$RecompensesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get libelle => $composableBuilder(
|
|
column: $table.libelle,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get coutPoints => $composableBuilder(
|
|
column: $table.coutPoints,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get icone => $composableBuilder(
|
|
column: $table.icone,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get actif => $composableBuilder(
|
|
column: $table.actif,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
Expression<bool> mouvementsRefs(
|
|
Expression<bool> Function($$MouvementsTableFilterComposer f) f,
|
|
) {
|
|
final $$MouvementsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.recompenseId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RecompensesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $RecompensesTable> {
|
|
$$RecompensesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get libelle => $composableBuilder(
|
|
column: $table.libelle,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get coutPoints => $composableBuilder(
|
|
column: $table.coutPoints,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get icone => $composableBuilder(
|
|
column: $table.icone,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get actif => $composableBuilder(
|
|
column: $table.actif,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get ordre => $composableBuilder(
|
|
column: $table.ordre,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$RecompensesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $RecompensesTable> {
|
|
$$RecompensesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get libelle =>
|
|
$composableBuilder(column: $table.libelle, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get coutPoints => $composableBuilder(
|
|
column: $table.coutPoints,
|
|
builder: (column) => column,
|
|
);
|
|
|
|
GeneratedColumn<String> get icone =>
|
|
$composableBuilder(column: $table.icone, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get actif =>
|
|
$composableBuilder(column: $table.actif, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get ordre =>
|
|
$composableBuilder(column: $table.ordre, builder: (column) => column);
|
|
|
|
Expression<T> mouvementsRefs<T extends Object>(
|
|
Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
|
|
) {
|
|
final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.id,
|
|
referencedTable: $db.mouvements,
|
|
getReferencedColumn: (t) => t.recompenseId,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$MouvementsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.mouvements,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return f(composer);
|
|
}
|
|
}
|
|
|
|
class $$RecompensesTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$RecompensesTable,
|
|
Recompense,
|
|
$$RecompensesTableFilterComposer,
|
|
$$RecompensesTableOrderingComposer,
|
|
$$RecompensesTableAnnotationComposer,
|
|
$$RecompensesTableCreateCompanionBuilder,
|
|
$$RecompensesTableUpdateCompanionBuilder,
|
|
(Recompense, $$RecompensesTableReferences),
|
|
Recompense,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
> {
|
|
$$RecompensesTableTableManager(_$AppDatabase db, $RecompensesTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$RecompensesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$RecompensesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$RecompensesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> libelle = const Value.absent(),
|
|
Value<int> coutPoints = const Value.absent(),
|
|
Value<String> icone = const Value.absent(),
|
|
Value<bool> actif = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
}) => RecompensesCompanion(
|
|
id: id,
|
|
libelle: libelle,
|
|
coutPoints: coutPoints,
|
|
icone: icone,
|
|
actif: actif,
|
|
ordre: ordre,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required String libelle,
|
|
required int coutPoints,
|
|
Value<String> icone = const Value.absent(),
|
|
Value<bool> actif = const Value.absent(),
|
|
Value<int> ordre = const Value.absent(),
|
|
}) => RecompensesCompanion.insert(
|
|
id: id,
|
|
libelle: libelle,
|
|
coutPoints: coutPoints,
|
|
icone: icone,
|
|
actif: actif,
|
|
ordre: ordre,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$RecompensesTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback: ({mouvementsRefs = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
|
|
addJoins: null,
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [
|
|
if (mouvementsRefs)
|
|
await $_getPrefetchedData<
|
|
Recompense,
|
|
$RecompensesTable,
|
|
Mouvement
|
|
>(
|
|
currentTable: table,
|
|
referencedTable: $$RecompensesTableReferences
|
|
._mouvementsRefsTable(db),
|
|
managerFromTypedResult: (p0) =>
|
|
$$RecompensesTableReferences(
|
|
db,
|
|
table,
|
|
p0,
|
|
).mouvementsRefs,
|
|
referencedItemsForCurrentItem: (item, referencedItems) =>
|
|
referencedItems.where(
|
|
(e) => e.recompenseId == item.id,
|
|
),
|
|
typedResults: items,
|
|
),
|
|
];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$RecompensesTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$RecompensesTable,
|
|
Recompense,
|
|
$$RecompensesTableFilterComposer,
|
|
$$RecompensesTableOrderingComposer,
|
|
$$RecompensesTableAnnotationComposer,
|
|
$$RecompensesTableCreateCompanionBuilder,
|
|
$$RecompensesTableUpdateCompanionBuilder,
|
|
(Recompense, $$RecompensesTableReferences),
|
|
Recompense,
|
|
PrefetchHooks Function({bool mouvementsRefs})
|
|
>;
|
|
typedef $$MouvementsTableCreateCompanionBuilder =
|
|
MouvementsCompanion Function({
|
|
Value<int> id,
|
|
required int enfantId,
|
|
Value<int?> regleId,
|
|
Value<int?> recompenseId,
|
|
required int delta,
|
|
Value<String?> note,
|
|
Value<DateTime> creeLe,
|
|
Value<bool> annule,
|
|
});
|
|
typedef $$MouvementsTableUpdateCompanionBuilder =
|
|
MouvementsCompanion Function({
|
|
Value<int> id,
|
|
Value<int> enfantId,
|
|
Value<int?> regleId,
|
|
Value<int?> recompenseId,
|
|
Value<int> delta,
|
|
Value<String?> note,
|
|
Value<DateTime> creeLe,
|
|
Value<bool> annule,
|
|
});
|
|
|
|
final class $$MouvementsTableReferences
|
|
extends BaseReferences<_$AppDatabase, $MouvementsTable, Mouvement> {
|
|
$$MouvementsTableReferences(super.$_db, super.$_table, super.$_typedResult);
|
|
|
|
static $EnfantsTable _enfantIdTable(_$AppDatabase db) =>
|
|
db.enfants.createAlias('mouvements__enfant_id__enfants__id');
|
|
|
|
$$EnfantsTableProcessedTableManager get enfantId {
|
|
final $_column = $_itemColumn<int>('enfant_id')!;
|
|
|
|
final manager = $$EnfantsTableTableManager(
|
|
$_db,
|
|
$_db.enfants,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_enfantIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $ReglesTable _regleIdTable(_$AppDatabase db) =>
|
|
db.regles.createAlias('mouvements__regle_id__regles__id');
|
|
|
|
$$ReglesTableProcessedTableManager? get regleId {
|
|
final $_column = $_itemColumn<int>('regle_id');
|
|
if ($_column == null) return null;
|
|
final manager = $$ReglesTableTableManager(
|
|
$_db,
|
|
$_db.regles,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_regleIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
|
|
static $RecompensesTable _recompenseIdTable(_$AppDatabase db) =>
|
|
db.recompenses.createAlias('mouvements__recompense_id__recompenses__id');
|
|
|
|
$$RecompensesTableProcessedTableManager? get recompenseId {
|
|
final $_column = $_itemColumn<int>('recompense_id');
|
|
if ($_column == null) return null;
|
|
final manager = $$RecompensesTableTableManager(
|
|
$_db,
|
|
$_db.recompenses,
|
|
).filter((f) => f.id.sqlEquals($_column));
|
|
final item = $_typedResult.readTableOrNull(_recompenseIdTable($_db));
|
|
if (item == null) return manager;
|
|
return ProcessedTableManager(
|
|
manager.$state.copyWith(prefetchedData: [item]),
|
|
);
|
|
}
|
|
}
|
|
|
|
class $$MouvementsTableFilterComposer
|
|
extends Composer<_$AppDatabase, $MouvementsTable> {
|
|
$$MouvementsTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<int> get delta => $composableBuilder(
|
|
column: $table.delta,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get note => $composableBuilder(
|
|
column: $table.note,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<DateTime> get creeLe => $composableBuilder(
|
|
column: $table.creeLe,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<bool> get annule => $composableBuilder(
|
|
column: $table.annule,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
$$EnfantsTableFilterComposer get enfantId {
|
|
final $$EnfantsTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.enfantId,
|
|
referencedTable: $db.enfants,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$EnfantsTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.enfants,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ReglesTableFilterComposer get regleId {
|
|
final $$ReglesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.regleId,
|
|
referencedTable: $db.regles,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ReglesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.regles,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$RecompensesTableFilterComposer get recompenseId {
|
|
final $$RecompensesTableFilterComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.recompenseId,
|
|
referencedTable: $db.recompenses,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RecompensesTableFilterComposer(
|
|
$db: $db,
|
|
$table: $db.recompenses,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$MouvementsTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $MouvementsTable> {
|
|
$$MouvementsTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<int> get delta => $composableBuilder(
|
|
column: $table.delta,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get note => $composableBuilder(
|
|
column: $table.note,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<DateTime> get creeLe => $composableBuilder(
|
|
column: $table.creeLe,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<bool> get annule => $composableBuilder(
|
|
column: $table.annule,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
$$EnfantsTableOrderingComposer get enfantId {
|
|
final $$EnfantsTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.enfantId,
|
|
referencedTable: $db.enfants,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$EnfantsTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.enfants,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ReglesTableOrderingComposer get regleId {
|
|
final $$ReglesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.regleId,
|
|
referencedTable: $db.regles,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ReglesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.regles,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$RecompensesTableOrderingComposer get recompenseId {
|
|
final $$RecompensesTableOrderingComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.recompenseId,
|
|
referencedTable: $db.recompenses,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RecompensesTableOrderingComposer(
|
|
$db: $db,
|
|
$table: $db.recompenses,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$MouvementsTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $MouvementsTable> {
|
|
$$MouvementsTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<int> get delta =>
|
|
$composableBuilder(column: $table.delta, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get note =>
|
|
$composableBuilder(column: $table.note, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get creeLe =>
|
|
$composableBuilder(column: $table.creeLe, builder: (column) => column);
|
|
|
|
GeneratedColumn<bool> get annule =>
|
|
$composableBuilder(column: $table.annule, builder: (column) => column);
|
|
|
|
$$EnfantsTableAnnotationComposer get enfantId {
|
|
final $$EnfantsTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.enfantId,
|
|
referencedTable: $db.enfants,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$EnfantsTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.enfants,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$ReglesTableAnnotationComposer get regleId {
|
|
final $$ReglesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.regleId,
|
|
referencedTable: $db.regles,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$ReglesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.regles,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
|
|
$$RecompensesTableAnnotationComposer get recompenseId {
|
|
final $$RecompensesTableAnnotationComposer composer = $composerBuilder(
|
|
composer: this,
|
|
getCurrentColumn: (t) => t.recompenseId,
|
|
referencedTable: $db.recompenses,
|
|
getReferencedColumn: (t) => t.id,
|
|
builder:
|
|
(
|
|
joinBuilder, {
|
|
$addJoinBuilderToRootComposer,
|
|
$removeJoinBuilderFromRootComposer,
|
|
}) => $$RecompensesTableAnnotationComposer(
|
|
$db: $db,
|
|
$table: $db.recompenses,
|
|
$addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
|
|
joinBuilder: joinBuilder,
|
|
$removeJoinBuilderFromRootComposer:
|
|
$removeJoinBuilderFromRootComposer,
|
|
),
|
|
);
|
|
return composer;
|
|
}
|
|
}
|
|
|
|
class $$MouvementsTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$MouvementsTable,
|
|
Mouvement,
|
|
$$MouvementsTableFilterComposer,
|
|
$$MouvementsTableOrderingComposer,
|
|
$$MouvementsTableAnnotationComposer,
|
|
$$MouvementsTableCreateCompanionBuilder,
|
|
$$MouvementsTableUpdateCompanionBuilder,
|
|
(Mouvement, $$MouvementsTableReferences),
|
|
Mouvement,
|
|
PrefetchHooks Function({
|
|
bool enfantId,
|
|
bool regleId,
|
|
bool recompenseId,
|
|
})
|
|
> {
|
|
$$MouvementsTableTableManager(_$AppDatabase db, $MouvementsTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$MouvementsTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$MouvementsTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$MouvementsTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
Value<int> enfantId = const Value.absent(),
|
|
Value<int?> regleId = const Value.absent(),
|
|
Value<int?> recompenseId = const Value.absent(),
|
|
Value<int> delta = const Value.absent(),
|
|
Value<String?> note = const Value.absent(),
|
|
Value<DateTime> creeLe = const Value.absent(),
|
|
Value<bool> annule = const Value.absent(),
|
|
}) => MouvementsCompanion(
|
|
id: id,
|
|
enfantId: enfantId,
|
|
regleId: regleId,
|
|
recompenseId: recompenseId,
|
|
delta: delta,
|
|
note: note,
|
|
creeLe: creeLe,
|
|
annule: annule,
|
|
),
|
|
createCompanionCallback:
|
|
({
|
|
Value<int> id = const Value.absent(),
|
|
required int enfantId,
|
|
Value<int?> regleId = const Value.absent(),
|
|
Value<int?> recompenseId = const Value.absent(),
|
|
required int delta,
|
|
Value<String?> note = const Value.absent(),
|
|
Value<DateTime> creeLe = const Value.absent(),
|
|
Value<bool> annule = const Value.absent(),
|
|
}) => MouvementsCompanion.insert(
|
|
id: id,
|
|
enfantId: enfantId,
|
|
regleId: regleId,
|
|
recompenseId: recompenseId,
|
|
delta: delta,
|
|
note: note,
|
|
creeLe: creeLe,
|
|
annule: annule,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map(
|
|
(e) => (
|
|
e.readTable(table),
|
|
$$MouvementsTableReferences(db, table, e),
|
|
),
|
|
)
|
|
.toList(),
|
|
prefetchHooksCallback:
|
|
({enfantId = false, regleId = false, recompenseId = false}) {
|
|
return PrefetchHooks(
|
|
db: db,
|
|
explicitlyWatchedTables: [],
|
|
addJoins:
|
|
<
|
|
T extends TableManagerState<
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic,
|
|
dynamic
|
|
>
|
|
>(state) {
|
|
if (enfantId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.enfantId,
|
|
referencedTable: $$MouvementsTableReferences
|
|
._enfantIdTable(db),
|
|
referencedColumn:
|
|
$$MouvementsTableReferences
|
|
._enfantIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (regleId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.regleId,
|
|
referencedTable: $$MouvementsTableReferences
|
|
._regleIdTable(db),
|
|
referencedColumn:
|
|
$$MouvementsTableReferences
|
|
._regleIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
if (recompenseId) {
|
|
state =
|
|
state.withJoin(
|
|
currentTable: table,
|
|
currentColumn: table.recompenseId,
|
|
referencedTable: $$MouvementsTableReferences
|
|
._recompenseIdTable(db),
|
|
referencedColumn:
|
|
$$MouvementsTableReferences
|
|
._recompenseIdTable(db)
|
|
.id,
|
|
)
|
|
as T;
|
|
}
|
|
|
|
return state;
|
|
},
|
|
getPrefetchedDataCallback: (items) async {
|
|
return [];
|
|
},
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$MouvementsTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$MouvementsTable,
|
|
Mouvement,
|
|
$$MouvementsTableFilterComposer,
|
|
$$MouvementsTableOrderingComposer,
|
|
$$MouvementsTableAnnotationComposer,
|
|
$$MouvementsTableCreateCompanionBuilder,
|
|
$$MouvementsTableUpdateCompanionBuilder,
|
|
(Mouvement, $$MouvementsTableReferences),
|
|
Mouvement,
|
|
PrefetchHooks Function({bool enfantId, bool regleId, bool recompenseId})
|
|
>;
|
|
typedef $$ConfigTableCreateCompanionBuilder =
|
|
ConfigCompanion Function({
|
|
required String cle,
|
|
required String valeur,
|
|
Value<int> rowid,
|
|
});
|
|
typedef $$ConfigTableUpdateCompanionBuilder =
|
|
ConfigCompanion Function({
|
|
Value<String> cle,
|
|
Value<String> valeur,
|
|
Value<int> rowid,
|
|
});
|
|
|
|
class $$ConfigTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ConfigTable> {
|
|
$$ConfigTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<String> get cle => $composableBuilder(
|
|
column: $table.cle,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
|
|
ColumnFilters<String> get valeur => $composableBuilder(
|
|
column: $table.valeur,
|
|
builder: (column) => ColumnFilters(column),
|
|
);
|
|
}
|
|
|
|
class $$ConfigTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ConfigTable> {
|
|
$$ConfigTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<String> get cle => $composableBuilder(
|
|
column: $table.cle,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
|
|
ColumnOrderings<String> get valeur => $composableBuilder(
|
|
column: $table.valeur,
|
|
builder: (column) => ColumnOrderings(column),
|
|
);
|
|
}
|
|
|
|
class $$ConfigTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ConfigTable> {
|
|
$$ConfigTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<String> get cle =>
|
|
$composableBuilder(column: $table.cle, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get valeur =>
|
|
$composableBuilder(column: $table.valeur, builder: (column) => column);
|
|
}
|
|
|
|
class $$ConfigTableTableManager
|
|
extends
|
|
RootTableManager<
|
|
_$AppDatabase,
|
|
$ConfigTable,
|
|
ConfigData,
|
|
$$ConfigTableFilterComposer,
|
|
$$ConfigTableOrderingComposer,
|
|
$$ConfigTableAnnotationComposer,
|
|
$$ConfigTableCreateCompanionBuilder,
|
|
$$ConfigTableUpdateCompanionBuilder,
|
|
(ConfigData, BaseReferences<_$AppDatabase, $ConfigTable, ConfigData>),
|
|
ConfigData,
|
|
PrefetchHooks Function()
|
|
> {
|
|
$$ConfigTableTableManager(_$AppDatabase db, $ConfigTable table)
|
|
: super(
|
|
TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ConfigTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ConfigTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ConfigTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback:
|
|
({
|
|
Value<String> cle = const Value.absent(),
|
|
Value<String> valeur = const Value.absent(),
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ConfigCompanion(cle: cle, valeur: valeur, rowid: rowid),
|
|
createCompanionCallback:
|
|
({
|
|
required String cle,
|
|
required String valeur,
|
|
Value<int> rowid = const Value.absent(),
|
|
}) => ConfigCompanion.insert(
|
|
cle: cle,
|
|
valeur: valeur,
|
|
rowid: rowid,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
),
|
|
);
|
|
}
|
|
|
|
typedef $$ConfigTableProcessedTableManager =
|
|
ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ConfigTable,
|
|
ConfigData,
|
|
$$ConfigTableFilterComposer,
|
|
$$ConfigTableOrderingComposer,
|
|
$$ConfigTableAnnotationComposer,
|
|
$$ConfigTableCreateCompanionBuilder,
|
|
$$ConfigTableUpdateCompanionBuilder,
|
|
(ConfigData, BaseReferences<_$AppDatabase, $ConfigTable, ConfigData>),
|
|
ConfigData,
|
|
PrefetchHooks Function()
|
|
>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$EnfantsTableTableManager get enfants =>
|
|
$$EnfantsTableTableManager(_db, _db.enfants);
|
|
$$ReglesTableTableManager get regles =>
|
|
$$ReglesTableTableManager(_db, _db.regles);
|
|
$$RecompensesTableTableManager get recompenses =>
|
|
$$RecompensesTableTableManager(_db, _db.recompenses);
|
|
$$MouvementsTableTableManager get mouvements =>
|
|
$$MouvementsTableTableManager(_db, _db.mouvements);
|
|
$$ConfigTableTableManager get config =>
|
|
$$ConfigTableTableManager(_db, _db.config);
|
|
}
|