655 lines
24 KiB
Dart
655 lines
24 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'app_database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $MedicationDosesTableTable extends MedicationDosesTable
|
|
with TableInfo<$MedicationDosesTableTable, MedicationDoseRecord> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$MedicationDosesTableTable(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 _compoundNameMeta =
|
|
const VerificationMeta('compoundName');
|
|
@override
|
|
late final GeneratedColumn<String> compoundName = GeneratedColumn<String>(
|
|
'compound_name', aliasedName, false,
|
|
additionalChecks:
|
|
GeneratedColumn.checkTextLength(minTextLength: 1, maxTextLength: 128),
|
|
type: DriftSqlType.string,
|
|
requiredDuringInsert: true);
|
|
static const VerificationMeta _doseMgMeta = const VerificationMeta('doseMg');
|
|
@override
|
|
late final GeneratedColumn<double> doseMg = GeneratedColumn<double>(
|
|
'dose_mg', aliasedName, false,
|
|
type: DriftSqlType.double, requiredDuringInsert: true);
|
|
static const VerificationMeta _scheduledTimeMeta =
|
|
const VerificationMeta('scheduledTime');
|
|
@override
|
|
late final GeneratedColumn<DateTime> scheduledTime =
|
|
GeneratedColumn<DateTime>('scheduled_time', aliasedName, false,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: true);
|
|
static const VerificationMeta _administeredTimeMeta =
|
|
const VerificationMeta('administeredTime');
|
|
@override
|
|
late final GeneratedColumn<DateTime> administeredTime =
|
|
GeneratedColumn<DateTime>('administered_time', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
static const VerificationMeta _injectionSiteMeta =
|
|
const VerificationMeta('injectionSite');
|
|
@override
|
|
late final GeneratedColumn<String> injectionSite = GeneratedColumn<String>(
|
|
'injection_site', aliasedName, true,
|
|
type: DriftSqlType.string, requiredDuringInsert: false);
|
|
static const VerificationMeta _notesMeta = const VerificationMeta('notes');
|
|
@override
|
|
late final GeneratedColumn<String> notes = GeneratedColumn<String>(
|
|
'notes', aliasedName, true,
|
|
type: DriftSqlType.string, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns => [
|
|
id,
|
|
compoundName,
|
|
doseMg,
|
|
scheduledTime,
|
|
administeredTime,
|
|
injectionSite,
|
|
notes
|
|
];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'medication_doses_table';
|
|
@override
|
|
VerificationContext validateIntegrity(
|
|
Insertable<MedicationDoseRecord> 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('compound_name')) {
|
|
context.handle(
|
|
_compoundNameMeta,
|
|
compoundName.isAcceptableOrUnknown(
|
|
data['compound_name']!, _compoundNameMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_compoundNameMeta);
|
|
}
|
|
if (data.containsKey('dose_mg')) {
|
|
context.handle(_doseMgMeta,
|
|
doseMg.isAcceptableOrUnknown(data['dose_mg']!, _doseMgMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_doseMgMeta);
|
|
}
|
|
if (data.containsKey('scheduled_time')) {
|
|
context.handle(
|
|
_scheduledTimeMeta,
|
|
scheduledTime.isAcceptableOrUnknown(
|
|
data['scheduled_time']!, _scheduledTimeMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_scheduledTimeMeta);
|
|
}
|
|
if (data.containsKey('administered_time')) {
|
|
context.handle(
|
|
_administeredTimeMeta,
|
|
administeredTime.isAcceptableOrUnknown(
|
|
data['administered_time']!, _administeredTimeMeta));
|
|
}
|
|
if (data.containsKey('injection_site')) {
|
|
context.handle(
|
|
_injectionSiteMeta,
|
|
injectionSite.isAcceptableOrUnknown(
|
|
data['injection_site']!, _injectionSiteMeta));
|
|
}
|
|
if (data.containsKey('notes')) {
|
|
context.handle(
|
|
_notesMeta, notes.isAcceptableOrUnknown(data['notes']!, _notesMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
MedicationDoseRecord map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return MedicationDoseRecord(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
compoundName: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}compound_name'])!,
|
|
doseMg: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.double, data['${effectivePrefix}dose_mg'])!,
|
|
scheduledTime: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime, data['${effectivePrefix}scheduled_time'])!,
|
|
administeredTime: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime, data['${effectivePrefix}administered_time']),
|
|
injectionSite: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}injection_site']),
|
|
notes: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}notes']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$MedicationDosesTableTable createAlias(String alias) {
|
|
return $MedicationDosesTableTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class MedicationDoseRecord extends DataClass
|
|
implements Insertable<MedicationDoseRecord> {
|
|
final int id;
|
|
|
|
/// Commercial or compounded name of the GLP-1/GIP agonist (e.g. Tirzepatide).
|
|
final String compoundName;
|
|
|
|
/// Total injected quantity in milligrams.
|
|
final double doseMg;
|
|
|
|
/// When the dose was prescribed to be taken (titration schedule anchor).
|
|
final DateTime scheduledTime;
|
|
|
|
/// When the dose was actually administered; `null` while still pending.
|
|
final DateTime? administeredTime;
|
|
|
|
/// Rotation quadrant identifier (e.g. `abdomenLeftLower`).
|
|
final String? injectionSite;
|
|
final String? notes;
|
|
const MedicationDoseRecord(
|
|
{required this.id,
|
|
required this.compoundName,
|
|
required this.doseMg,
|
|
required this.scheduledTime,
|
|
this.administeredTime,
|
|
this.injectionSite,
|
|
this.notes});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['compound_name'] = Variable<String>(compoundName);
|
|
map['dose_mg'] = Variable<double>(doseMg);
|
|
map['scheduled_time'] = Variable<DateTime>(scheduledTime);
|
|
if (!nullToAbsent || administeredTime != null) {
|
|
map['administered_time'] = Variable<DateTime>(administeredTime);
|
|
}
|
|
if (!nullToAbsent || injectionSite != null) {
|
|
map['injection_site'] = Variable<String>(injectionSite);
|
|
}
|
|
if (!nullToAbsent || notes != null) {
|
|
map['notes'] = Variable<String>(notes);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
MedicationDosesTableCompanion toCompanion(bool nullToAbsent) {
|
|
return MedicationDosesTableCompanion(
|
|
id: Value(id),
|
|
compoundName: Value(compoundName),
|
|
doseMg: Value(doseMg),
|
|
scheduledTime: Value(scheduledTime),
|
|
administeredTime: administeredTime == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(administeredTime),
|
|
injectionSite: injectionSite == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(injectionSite),
|
|
notes:
|
|
notes == null && nullToAbsent ? const Value.absent() : Value(notes),
|
|
);
|
|
}
|
|
|
|
factory MedicationDoseRecord.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return MedicationDoseRecord(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
compoundName: serializer.fromJson<String>(json['compoundName']),
|
|
doseMg: serializer.fromJson<double>(json['doseMg']),
|
|
scheduledTime: serializer.fromJson<DateTime>(json['scheduledTime']),
|
|
administeredTime:
|
|
serializer.fromJson<DateTime?>(json['administeredTime']),
|
|
injectionSite: serializer.fromJson<String?>(json['injectionSite']),
|
|
notes: serializer.fromJson<String?>(json['notes']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'compoundName': serializer.toJson<String>(compoundName),
|
|
'doseMg': serializer.toJson<double>(doseMg),
|
|
'scheduledTime': serializer.toJson<DateTime>(scheduledTime),
|
|
'administeredTime': serializer.toJson<DateTime?>(administeredTime),
|
|
'injectionSite': serializer.toJson<String?>(injectionSite),
|
|
'notes': serializer.toJson<String?>(notes),
|
|
};
|
|
}
|
|
|
|
MedicationDoseRecord copyWith(
|
|
{int? id,
|
|
String? compoundName,
|
|
double? doseMg,
|
|
DateTime? scheduledTime,
|
|
Value<DateTime?> administeredTime = const Value.absent(),
|
|
Value<String?> injectionSite = const Value.absent(),
|
|
Value<String?> notes = const Value.absent()}) =>
|
|
MedicationDoseRecord(
|
|
id: id ?? this.id,
|
|
compoundName: compoundName ?? this.compoundName,
|
|
doseMg: doseMg ?? this.doseMg,
|
|
scheduledTime: scheduledTime ?? this.scheduledTime,
|
|
administeredTime: administeredTime.present
|
|
? administeredTime.value
|
|
: this.administeredTime,
|
|
injectionSite:
|
|
injectionSite.present ? injectionSite.value : this.injectionSite,
|
|
notes: notes.present ? notes.value : this.notes,
|
|
);
|
|
MedicationDoseRecord copyWithCompanion(MedicationDosesTableCompanion data) {
|
|
return MedicationDoseRecord(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
compoundName: data.compoundName.present
|
|
? data.compoundName.value
|
|
: this.compoundName,
|
|
doseMg: data.doseMg.present ? data.doseMg.value : this.doseMg,
|
|
scheduledTime: data.scheduledTime.present
|
|
? data.scheduledTime.value
|
|
: this.scheduledTime,
|
|
administeredTime: data.administeredTime.present
|
|
? data.administeredTime.value
|
|
: this.administeredTime,
|
|
injectionSite: data.injectionSite.present
|
|
? data.injectionSite.value
|
|
: this.injectionSite,
|
|
notes: data.notes.present ? data.notes.value : this.notes,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MedicationDoseRecord(')
|
|
..write('id: $id, ')
|
|
..write('compoundName: $compoundName, ')
|
|
..write('doseMg: $doseMg, ')
|
|
..write('scheduledTime: $scheduledTime, ')
|
|
..write('administeredTime: $administeredTime, ')
|
|
..write('injectionSite: $injectionSite, ')
|
|
..write('notes: $notes')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(id, compoundName, doseMg, scheduledTime,
|
|
administeredTime, injectionSite, notes);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is MedicationDoseRecord &&
|
|
other.id == this.id &&
|
|
other.compoundName == this.compoundName &&
|
|
other.doseMg == this.doseMg &&
|
|
other.scheduledTime == this.scheduledTime &&
|
|
other.administeredTime == this.administeredTime &&
|
|
other.injectionSite == this.injectionSite &&
|
|
other.notes == this.notes);
|
|
}
|
|
|
|
class MedicationDosesTableCompanion
|
|
extends UpdateCompanion<MedicationDoseRecord> {
|
|
final Value<int> id;
|
|
final Value<String> compoundName;
|
|
final Value<double> doseMg;
|
|
final Value<DateTime> scheduledTime;
|
|
final Value<DateTime?> administeredTime;
|
|
final Value<String?> injectionSite;
|
|
final Value<String?> notes;
|
|
const MedicationDosesTableCompanion({
|
|
this.id = const Value.absent(),
|
|
this.compoundName = const Value.absent(),
|
|
this.doseMg = const Value.absent(),
|
|
this.scheduledTime = const Value.absent(),
|
|
this.administeredTime = const Value.absent(),
|
|
this.injectionSite = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
});
|
|
MedicationDosesTableCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String compoundName,
|
|
required double doseMg,
|
|
required DateTime scheduledTime,
|
|
this.administeredTime = const Value.absent(),
|
|
this.injectionSite = const Value.absent(),
|
|
this.notes = const Value.absent(),
|
|
}) : compoundName = Value(compoundName),
|
|
doseMg = Value(doseMg),
|
|
scheduledTime = Value(scheduledTime);
|
|
static Insertable<MedicationDoseRecord> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? compoundName,
|
|
Expression<double>? doseMg,
|
|
Expression<DateTime>? scheduledTime,
|
|
Expression<DateTime>? administeredTime,
|
|
Expression<String>? injectionSite,
|
|
Expression<String>? notes,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (compoundName != null) 'compound_name': compoundName,
|
|
if (doseMg != null) 'dose_mg': doseMg,
|
|
if (scheduledTime != null) 'scheduled_time': scheduledTime,
|
|
if (administeredTime != null) 'administered_time': administeredTime,
|
|
if (injectionSite != null) 'injection_site': injectionSite,
|
|
if (notes != null) 'notes': notes,
|
|
});
|
|
}
|
|
|
|
MedicationDosesTableCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? compoundName,
|
|
Value<double>? doseMg,
|
|
Value<DateTime>? scheduledTime,
|
|
Value<DateTime?>? administeredTime,
|
|
Value<String?>? injectionSite,
|
|
Value<String?>? notes}) {
|
|
return MedicationDosesTableCompanion(
|
|
id: id ?? this.id,
|
|
compoundName: compoundName ?? this.compoundName,
|
|
doseMg: doseMg ?? this.doseMg,
|
|
scheduledTime: scheduledTime ?? this.scheduledTime,
|
|
administeredTime: administeredTime ?? this.administeredTime,
|
|
injectionSite: injectionSite ?? this.injectionSite,
|
|
notes: notes ?? this.notes,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (compoundName.present) {
|
|
map['compound_name'] = Variable<String>(compoundName.value);
|
|
}
|
|
if (doseMg.present) {
|
|
map['dose_mg'] = Variable<double>(doseMg.value);
|
|
}
|
|
if (scheduledTime.present) {
|
|
map['scheduled_time'] = Variable<DateTime>(scheduledTime.value);
|
|
}
|
|
if (administeredTime.present) {
|
|
map['administered_time'] = Variable<DateTime>(administeredTime.value);
|
|
}
|
|
if (injectionSite.present) {
|
|
map['injection_site'] = Variable<String>(injectionSite.value);
|
|
}
|
|
if (notes.present) {
|
|
map['notes'] = Variable<String>(notes.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('MedicationDosesTableCompanion(')
|
|
..write('id: $id, ')
|
|
..write('compoundName: $compoundName, ')
|
|
..write('doseMg: $doseMg, ')
|
|
..write('scheduledTime: $scheduledTime, ')
|
|
..write('administeredTime: $administeredTime, ')
|
|
..write('injectionSite: $injectionSite, ')
|
|
..write('notes: $notes')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $MedicationDosesTableTable medicationDosesTable =
|
|
$MedicationDosesTableTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [medicationDosesTable];
|
|
}
|
|
|
|
typedef $$MedicationDosesTableTableCreateCompanionBuilder
|
|
= MedicationDosesTableCompanion Function({
|
|
Value<int> id,
|
|
required String compoundName,
|
|
required double doseMg,
|
|
required DateTime scheduledTime,
|
|
Value<DateTime?> administeredTime,
|
|
Value<String?> injectionSite,
|
|
Value<String?> notes,
|
|
});
|
|
typedef $$MedicationDosesTableTableUpdateCompanionBuilder
|
|
= MedicationDosesTableCompanion Function({
|
|
Value<int> id,
|
|
Value<String> compoundName,
|
|
Value<double> doseMg,
|
|
Value<DateTime> scheduledTime,
|
|
Value<DateTime?> administeredTime,
|
|
Value<String?> injectionSite,
|
|
Value<String?> notes,
|
|
});
|
|
|
|
class $$MedicationDosesTableTableFilterComposer
|
|
extends Composer<_$AppDatabase, $MedicationDosesTableTable> {
|
|
$$MedicationDosesTableTableFilterComposer({
|
|
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 compoundName => $composableBuilder(
|
|
column: $table.compoundName, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<double> get doseMg => $composableBuilder(
|
|
column: $table.doseMg, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get scheduledTime => $composableBuilder(
|
|
column: $table.scheduledTime, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get administeredTime => $composableBuilder(
|
|
column: $table.administeredTime,
|
|
builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get injectionSite => $composableBuilder(
|
|
column: $table.injectionSite, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get notes => $composableBuilder(
|
|
column: $table.notes, builder: (column) => ColumnFilters(column));
|
|
}
|
|
|
|
class $$MedicationDosesTableTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $MedicationDosesTableTable> {
|
|
$$MedicationDosesTableTableOrderingComposer({
|
|
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 compoundName => $composableBuilder(
|
|
column: $table.compoundName,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<double> get doseMg => $composableBuilder(
|
|
column: $table.doseMg, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get scheduledTime => $composableBuilder(
|
|
column: $table.scheduledTime,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get administeredTime => $composableBuilder(
|
|
column: $table.administeredTime,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get injectionSite => $composableBuilder(
|
|
column: $table.injectionSite,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get notes => $composableBuilder(
|
|
column: $table.notes, builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$MedicationDosesTableTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $MedicationDosesTableTable> {
|
|
$$MedicationDosesTableTableAnnotationComposer({
|
|
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 compoundName => $composableBuilder(
|
|
column: $table.compoundName, builder: (column) => column);
|
|
|
|
GeneratedColumn<double> get doseMg =>
|
|
$composableBuilder(column: $table.doseMg, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get scheduledTime => $composableBuilder(
|
|
column: $table.scheduledTime, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get administeredTime => $composableBuilder(
|
|
column: $table.administeredTime, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get injectionSite => $composableBuilder(
|
|
column: $table.injectionSite, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get notes =>
|
|
$composableBuilder(column: $table.notes, builder: (column) => column);
|
|
}
|
|
|
|
class $$MedicationDosesTableTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$MedicationDosesTableTable,
|
|
MedicationDoseRecord,
|
|
$$MedicationDosesTableTableFilterComposer,
|
|
$$MedicationDosesTableTableOrderingComposer,
|
|
$$MedicationDosesTableTableAnnotationComposer,
|
|
$$MedicationDosesTableTableCreateCompanionBuilder,
|
|
$$MedicationDosesTableTableUpdateCompanionBuilder,
|
|
(
|
|
MedicationDoseRecord,
|
|
BaseReferences<_$AppDatabase, $MedicationDosesTableTable,
|
|
MedicationDoseRecord>
|
|
),
|
|
MedicationDoseRecord,
|
|
PrefetchHooks Function()> {
|
|
$$MedicationDosesTableTableTableManager(
|
|
_$AppDatabase db, $MedicationDosesTableTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$MedicationDosesTableTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$MedicationDosesTableTableOrderingComposer(
|
|
$db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$MedicationDosesTableTableAnnotationComposer(
|
|
$db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> compoundName = const Value.absent(),
|
|
Value<double> doseMg = const Value.absent(),
|
|
Value<DateTime> scheduledTime = const Value.absent(),
|
|
Value<DateTime?> administeredTime = const Value.absent(),
|
|
Value<String?> injectionSite = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
}) =>
|
|
MedicationDosesTableCompanion(
|
|
id: id,
|
|
compoundName: compoundName,
|
|
doseMg: doseMg,
|
|
scheduledTime: scheduledTime,
|
|
administeredTime: administeredTime,
|
|
injectionSite: injectionSite,
|
|
notes: notes,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String compoundName,
|
|
required double doseMg,
|
|
required DateTime scheduledTime,
|
|
Value<DateTime?> administeredTime = const Value.absent(),
|
|
Value<String?> injectionSite = const Value.absent(),
|
|
Value<String?> notes = const Value.absent(),
|
|
}) =>
|
|
MedicationDosesTableCompanion.insert(
|
|
id: id,
|
|
compoundName: compoundName,
|
|
doseMg: doseMg,
|
|
scheduledTime: scheduledTime,
|
|
administeredTime: administeredTime,
|
|
injectionSite: injectionSite,
|
|
notes: notes,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (
|
|
e.readTable<$MedicationDosesTableTable,
|
|
MedicationDoseRecord>(table),
|
|
BaseReferences<_$AppDatabase, $MedicationDosesTableTable,
|
|
MedicationDoseRecord>(db, table, e)
|
|
))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
));
|
|
}
|
|
|
|
typedef $$MedicationDosesTableTableProcessedTableManager
|
|
= ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$MedicationDosesTableTable,
|
|
MedicationDoseRecord,
|
|
$$MedicationDosesTableTableFilterComposer,
|
|
$$MedicationDosesTableTableOrderingComposer,
|
|
$$MedicationDosesTableTableAnnotationComposer,
|
|
$$MedicationDosesTableTableCreateCompanionBuilder,
|
|
$$MedicationDosesTableTableUpdateCompanionBuilder,
|
|
(
|
|
MedicationDoseRecord,
|
|
BaseReferences<_$AppDatabase, $MedicationDosesTableTable,
|
|
MedicationDoseRecord>
|
|
),
|
|
MedicationDoseRecord,
|
|
PrefetchHooks Function()>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$MedicationDosesTableTableTableManager get medicationDosesTable =>
|
|
$$MedicationDosesTableTableTableManager(_db, _db.medicationDosesTable);
|
|
}
|