halkyon-days/halkyon
Watch
1
0
Fork
You've already forked halkyon
 0
Code Issues Pull requests Projects Releases 37 Packages Wiki Activity Actions

feat(train): equipment by place and a plate calculator (ADR 0034)

Browse source 
The places a person trains at (home, a gym), each a sealed, synced
`training_place` row with its equipment: bars and handles with their own
weight, plates by weight and count, dumbbells and kettlebells, the rest
by count, the person's own by name. A new place starts from what a home
or a gym usually has. The place last chosen is remembered on the device,
never its location.

The plate calculator loads each weight both sides alike, the heaviest
load not above it with the fewest plates, heavier inside, and over a
series of sets picks the loads making the fewest plate moves, listing
what comes off and goes on. Equipment is in Settings; strength plans
are to build on it.

The migration only creates the table, its space index and its cascade
to the sync engine's spaces.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Tizian 「ティツィアーン」 <raisondetredev@pm.me>
This commit is contained in:
Tizian 「ティツィアーン」 2026-11-02 11:59:24 +01:00
commit 064b911aa2
Signed by: raisondetredev
GPG key ID: 07F6FCF405488B64
4 changed files with 24759 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

19
apps/train/halkyon_train_server/lib/src/equipment/training_place.spy.yaml Normal file
View file

@ -0,0 +1,19 @@
### A place the person trains at and its equipment (ADR 0034): its name and
### items (bars and handles with their weight, plates and weights by weight
### and count, benches, racks and the person's own), in its sealed payload
### (ADR 0030, D7); the instance sees that it exists, its size and when it
### changed. Changed when edited, the last writer winning. Synced.
class: TrainingPlace
table: training_place
database: sync
fields:
### The key it is sealed with (ADR 0002's envelope); never null in Train.
keyId: String?
### The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
payload: ByteData
### The sealing's nonce (ADR 0002's envelope).
nonce: ByteData?
indexes:
# Deleting a space finds its rows through this index (see content_key).
training_place_space_idx:
fields: spaceId

669
apps/train/halkyon_train_server/lib/src/generated/equipment/training_place.dart Normal file
View file

@ -0,0 +1,669 @@
/* AUTOMATICALLY GENERATED CODE DO NOT MODIFY */
/* To generate run: "serverpod generate" */
// ignore_for_file: implementation_imports
// ignore_for_file: library_private_types_in_public_api
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: public_member_api_docs
// ignore_for_file: type_literal_in_constant_pattern
// ignore_for_file: use_super_parameters
// ignore_for_file: invalid_use_of_internal_member
// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'dart:typed_data' as _idt;
import 'package:serverpod/serverpod.dart' as _is;
/// A place the person trains at and its equipment (ADR 0034): its name and
/// items (bars and handles with their weight, plates and weights by weight
/// and count, benches, racks and the person's own), in its sealed payload
/// (ADR 0030, D7); the instance sees that it exists, its size and when it
/// changed. Changed when edited, the last writer winning. Synced.
abstract class TrainingPlace
implements _is.TableRow<_is.UuidValue?>, _is.ProtocolSerialization {
TrainingPlace._({
this.id,
this.spaceId,
this.keyId,
required this.payload,
this.nonce,
});
factory TrainingPlace({
_is.UuidValue? id,
int? spaceId,
String? keyId,
required _idt.ByteData payload,
_idt.ByteData? nonce,
}) = _TrainingPlaceImpl;
factory TrainingPlace.fromJson(Map<String, dynamic> jsonSerialization) {
return TrainingPlace(
id: jsonSerialization['id'] == null
? null
: _is.UuidValueJsonExtension.fromJson(jsonSerialization['id']),
spaceId: jsonSerialization['spaceId'] as int?,
keyId: jsonSerialization['keyId'] as String?,
payload: _is.ByteDataJsonExtension.fromJson(jsonSerialization['payload']),
nonce: jsonSerialization['nonce'] == null
? null
: _is.ByteDataJsonExtension.fromJson(jsonSerialization['nonce']),
);
}
static final t = TrainingPlaceTable();
static const db = TrainingPlaceRepository._();
@override
_is.UuidValue? id;
/// The space owning this row. Maintained by the sync engine.
int? spaceId;
/// The key it is sealed with (ADR 0002's envelope); never null in Train.
String? keyId;
/// The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
_idt.ByteData payload;
/// The sealing's nonce (ADR 0002's envelope).
_idt.ByteData? nonce;
@override
_is.Table<_is.UuidValue?> get table => t;
/// Returns a shallow copy of this [TrainingPlace]
/// with some or all fields replaced by the given arguments.
@_is.useResult
TrainingPlace copyWith({
_is.UuidValue? id,
int? spaceId,
String? keyId,
_idt.ByteData? payload,
_idt.ByteData? nonce,
});
@override
Map<String, dynamic> toJson() {
return {
'__className__': 'TrainingPlace',
if (id != null) 'id': id?.toJson(),
if (spaceId != null) 'spaceId': spaceId,
if (keyId != null) 'keyId': keyId,
'payload': payload.toJson(),
if (nonce != null) 'nonce': nonce?.toJson(),
};
}
@override
Map<String, dynamic> toJsonForProtocol() {
return {
'__className__': 'TrainingPlace',
if (id != null) 'id': id?.toJson(),
if (spaceId != null) 'spaceId': spaceId,
if (keyId != null) 'keyId': keyId,
'payload': payload.toJson(),
if (nonce != null) 'nonce': nonce?.toJson(),
};
}
static TrainingPlaceInclude include() {
return TrainingPlaceInclude._();
}
static TrainingPlaceIncludeList includeList({
_is.WhereExpressionBuilder<TrainingPlaceTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
TrainingPlaceInclude? include,
}) {
return TrainingPlaceIncludeList._(
where: where,
limit: limit,
offset: offset,
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
include: include,
);
}
@override
String toString() {
return _is.SerializationManager.encode(this);
}
}
class _Undefined {}
class _TrainingPlaceImpl extends TrainingPlace {
_TrainingPlaceImpl({
_is.UuidValue? id,
int? spaceId,
String? keyId,
required _idt.ByteData payload,
_idt.ByteData? nonce,
}) : super._(
id: id,
spaceId: spaceId,
keyId: keyId,
payload: payload,
nonce: nonce,
);
/// Returns a shallow copy of this [TrainingPlace]
/// with some or all fields replaced by the given arguments.
@_is.useResult
@override
TrainingPlace copyWith({
Object? id = _Undefined,
Object? spaceId = _Undefined,
Object? keyId = _Undefined,
_idt.ByteData? payload,
Object? nonce = _Undefined,
}) {
return TrainingPlace(
id: id is _is.UuidValue? ? id : this.id,
spaceId: spaceId is int? ? spaceId : this.spaceId,
keyId: keyId is String? ? keyId : this.keyId,
payload: payload ?? this.payload.clone(),
nonce: nonce is _idt.ByteData? ? nonce : this.nonce?.clone(),
);
}
}
class TrainingPlaceUpdateTable extends _is.UpdateTable<TrainingPlaceTable> {
TrainingPlaceUpdateTable(super.table);
_is.ColumnValue<int, int> spaceId(int? value) => _is.ColumnValue(
table.spaceId,
value,
);
_is.ColumnValue<String, String> keyId(String? value) => _is.ColumnValue(
table.keyId,
value,
);
_is.ColumnValue<_idt.ByteData, _idt.ByteData> payload(_idt.ByteData value) =>
_is.ColumnValue(
table.payload,
value,
);
_is.ColumnValue<_idt.ByteData, _idt.ByteData> nonce(_idt.ByteData? value) =>
_is.ColumnValue(
table.nonce,
value,
);
}
class TrainingPlaceTable extends _is.Table<_is.UuidValue?> {
TrainingPlaceTable({super.tableRelation})
: super(tableName: 'training_place') {
updateTable = TrainingPlaceUpdateTable(this);
spaceId = _is.ColumnInt(
'spaceId',
this,
);
keyId = _is.ColumnString(
'keyId',
this,
);
payload = _is.ColumnByteData(
'payload',
this,
);
nonce = _is.ColumnByteData(
'nonce',
this,
);
}
late final TrainingPlaceUpdateTable updateTable;
/// The space owning this row. Maintained by the sync engine.
late final _is.ColumnInt spaceId;
/// The key it is sealed with (ADR 0002's envelope); never null in Train.
late final _is.ColumnString keyId;
/// The content, sealed: UTF-8 JSON with a `schemaVersion` once opened.
late final _is.ColumnByteData payload;
/// The sealing's nonce (ADR 0002's envelope).
late final _is.ColumnByteData nonce;
@override
List<_is.Column> get columns => [
id,
spaceId,
keyId,
payload,
nonce,
];
}
class TrainingPlaceInclude extends _is.IncludeObject {
TrainingPlaceInclude._();
@override
Map<String, _is.Include?> get includes => {};
@override
_is.Table<_is.UuidValue?> get table => TrainingPlace.t;
}
class TrainingPlaceIncludeList extends _is.IncludeList {
TrainingPlaceIncludeList._({
_is.WhereExpressionBuilder<TrainingPlaceTable>? where,
super.limit,
super.offset,
super.orderBy,
super.orderByList,
super.include,
}) {
super.where = where?.call(TrainingPlace.t);
}
@override
Map<String, _is.Include?> get includes => include?.includes ?? {};
@override
_is.Table<_is.UuidValue?> get table => TrainingPlace.t;
}
class TrainingPlaceRepository {
const TrainingPlaceRepository._();
/// Returns a list of [TrainingPlace]s matching the given query parameters.
///
/// Use [where] to specify which items to include in the return value.
/// If none is specified, all items will be returned.
///
/// To specify the order of the items use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// The maximum number of items can be set by [limit]. If no limit is set,
/// all items matching the query will be returned.
///
/// [offset] defines how many items to skip, after which [limit] (or all)
/// items are read from the database.
///
/// ```dart
/// var persons = await Persons.db.find(
/// session,
/// where: (t) => t.lastName.equals('Jones'),
/// orderBy: (t) => t.firstName,
/// limit: 100,
/// );
/// ```
Future<List<TrainingPlace>> find(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<TrainingPlaceTable>? where,
int? limit,
int? offset,
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.find<TrainingPlace>(
where: where?.call(TrainingPlace.t),
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
limit: limit,
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Returns the first matching [TrainingPlace] matching the given query parameters.
///
/// Use [where] to specify which items to include in the return value.
/// If none is specified, all items will be returned.
///
/// To specify the order use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// [offset] defines how many items to skip, after which the next one will be picked.
///
/// ```dart
/// var youngestPerson = await Persons.db.findFirstRow(
/// session,
/// where: (t) => t.lastName.equals('Jones'),
/// orderBy: (t) => t.age,
/// );
/// ```
Future<TrainingPlace?> findFirstRow(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<TrainingPlaceTable>? where,
int? offset,
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findFirstRow<TrainingPlace>(
where: where?.call(TrainingPlace.t),
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
offset: offset,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Finds a single [TrainingPlace] by its [id] or null if no such row exists.
Future<TrainingPlace?> findById(
_is.DatabaseSession session,
_is.UuidValue id, {
_is.Transaction? transaction,
_is.LockMode? lockMode,
_is.LockBehavior? lockBehavior,
}) async {
return session.db.findById<TrainingPlace>(
id,
transaction: transaction,
lockMode: lockMode,
lockBehavior: lockBehavior,
);
}
/// Inserts all [TrainingPlace]s in the list and returns the inserted rows.
///
/// The returned [TrainingPlace]s will have their `id` fields set.
///
/// This is an atomic operation, meaning that if one of the rows fails to
/// insert, none of the rows will be inserted.
///
/// If [ignoreConflicts] is set to `true`, rows that conflict with existing
/// rows are silently skipped, and only the successfully inserted rows are
/// returned.
///
/// If [noReturn] is set to `true`, the inserted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> insert(
_is.DatabaseSession session,
List<TrainingPlace> rows, {
_is.Transaction? transaction,
bool ignoreConflicts = false,
bool noReturn = false,
}) async {
return session.db.insert<TrainingPlace>(
rows,
transaction: transaction,
ignoreConflicts: ignoreConflicts,
noReturn: noReturn,
);
}
/// Inserts a single [TrainingPlace] and returns the inserted row.
///
/// The returned [TrainingPlace] will have its `id` field set.
Future<TrainingPlace> insertRow(
_is.DatabaseSession session,
TrainingPlace row, {
_is.Transaction? transaction,
}) async {
return session.db.insertRow<TrainingPlace>(
row,
transaction: transaction,
);
}
/// Upserts all [TrainingPlace]s in the list and returns the resulting rows.
///
/// If a row conflicts on the given [conflictColumns], the existing row is
/// updated with the new values. Otherwise, a new row is inserted.
///
/// If [updateColumns] is provided, only those columns will be updated on
/// conflict. If null, all non-conflict, non-id columns are updated.
///
/// If [updateWhere] is provided, the update only applies to rows matching the
/// given expression. Conflicting rows that don't match are skipped and not
/// returned, so the resulting list may be shorter than [rows].
///
/// The returned [TrainingPlace]s will have their `id` fields set.
///
/// This is an atomic operation, meaning that if one of the rows fails,
/// none of the rows will be affected.
///
/// If [noReturn] is set to `true`, the resulting rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> upsert(
_is.DatabaseSession session,
List<TrainingPlace> rows, {
required _is.ColumnSelections<TrainingPlaceTable> conflictColumns,
_is.ColumnSelections<TrainingPlaceTable>? updateColumns,
_is.WhereExpressionBuilder<TrainingPlaceTable>? updateWhere,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.upsert<TrainingPlace>(
rows,
conflictColumns: conflictColumns(TrainingPlace.t),
updateColumns: updateColumns?.call(TrainingPlace.t),
updateWhere: updateWhere?.call(TrainingPlace.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Upserts a single [TrainingPlace] and returns the resulting row.
///
/// If the row conflicts on the given [conflictColumns], the existing row is
/// updated. Otherwise, a new row is inserted.
///
/// If [updateColumns] is provided, only those columns will be updated on
/// conflict. If null, all non-conflict, non-id columns are updated.
///
/// If [updateWhere] is provided, the update only applies when the existing
/// row matches the expression. Returns `null` if no row was affected — for
/// example when [updateWhere] does not match the conflicting row.
///
/// The returned [TrainingPlace] will have its `id` field set.
Future<TrainingPlace?> upsertRow(
_is.DatabaseSession session,
TrainingPlace row, {
required _is.ColumnSelections<TrainingPlaceTable> conflictColumns,
_is.ColumnSelections<TrainingPlaceTable>? updateColumns,
_is.WhereExpressionBuilder<TrainingPlaceTable>? updateWhere,
_is.Transaction? transaction,
}) async {
return session.db.upsertRow<TrainingPlace>(
row,
conflictColumns: conflictColumns(TrainingPlace.t),
updateColumns: updateColumns?.call(TrainingPlace.t),
updateWhere: updateWhere?.call(TrainingPlace.t),
transaction: transaction,
);
}
/// Updates all [TrainingPlace]s in the list and returns the updated rows. If
/// [columns] is provided, only those columns will be updated. Defaults to
/// all columns.
/// This is an atomic operation, meaning that if one of the rows fails to
/// update, none of the rows will be updated.
///
/// If [noReturn] is set to `true`, the updated rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> update(
_is.DatabaseSession session,
List<TrainingPlace> rows, {
_is.ColumnSelections<TrainingPlaceTable>? columns,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.update<TrainingPlace>(
rows,
columns: columns?.call(TrainingPlace.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Updates a single [TrainingPlace]. The row needs to have its id set.
/// Optionally, a list of [columns] can be provided to only update those
/// columns. Defaults to all columns.
Future<TrainingPlace> updateRow(
_is.DatabaseSession session,
TrainingPlace row, {
_is.ColumnSelections<TrainingPlaceTable>? columns,
_is.Transaction? transaction,
}) async {
return session.db.updateRow<TrainingPlace>(
row,
columns: columns?.call(TrainingPlace.t),
transaction: transaction,
);
}
/// Updates a single [TrainingPlace] by its [id] with the specified [columnValues].
/// Returns the updated row or null if no row with the given id exists.
Future<TrainingPlace?> updateById(
_is.DatabaseSession session,
_is.UuidValue id, {
required _is.ColumnValueListBuilder<TrainingPlaceUpdateTable> columnValues,
_is.Transaction? transaction,
}) async {
return session.db.updateById<TrainingPlace>(
id,
columnValues: columnValues(TrainingPlace.t.updateTable),
transaction: transaction,
);
}
/// Updates all [TrainingPlace]s matching the [where] expression with the specified [columnValues].
/// Returns the list of updated rows.
///
/// If [noReturn] is set to `true`, the updated rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> updateWhere(
_is.DatabaseSession session, {
required _is.ColumnValueListBuilder<TrainingPlaceUpdateTable> columnValues,
required _is.WhereExpressionBuilder<TrainingPlaceTable> where,
int? limit,
int? offset,
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.updateWhere<TrainingPlace>(
columnValues: columnValues(TrainingPlace.t.updateTable),
where: where(TrainingPlace.t),
limit: limit,
offset: offset,
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes all [TrainingPlace]s in the list and returns the deleted rows.
///
/// To specify the order of the returned rows use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// This is an atomic operation, meaning that if one of the rows fail to
/// be deleted, none of the rows will be deleted.
///
/// If [noReturn] is set to `true`, the deleted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> delete(
_is.DatabaseSession session,
List<TrainingPlace> rows, {
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.delete<TrainingPlace>(
rows,
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Deletes a single [TrainingPlace].
Future<TrainingPlace> deleteRow(
_is.DatabaseSession session,
TrainingPlace row, {
_is.Transaction? transaction,
}) async {
return session.db.deleteRow<TrainingPlace>(
row,
transaction: transaction,
);
}
/// Deletes all rows matching the [where] expression.
///
/// To specify the order of the returned rows use [orderBy] or [orderByList]
/// when sorting by multiple columns.
///
/// If [noReturn] is set to `true`, the deleted rows are not read back from
/// the database and an empty list is returned. This avoids the overhead of
/// transferring and deserializing the rows when the result is not needed.
Future<List<TrainingPlace>> deleteWhere(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<TrainingPlaceTable> where,
_is.OrderByBuilder<TrainingPlaceTable>? orderBy,
_is.OrderByListBuilder<TrainingPlaceTable>? orderByList,
_is.Transaction? transaction,
bool noReturn = false,
}) async {
return session.db.deleteWhere<TrainingPlace>(
where: where(TrainingPlace.t),
orderBy: orderBy?.call(TrainingPlace.t),
orderByList: orderByList?.call(TrainingPlace.t),
transaction: transaction,
noReturn: noReturn,
);
}
/// Counts the number of rows matching the [where] expression. If omitted,
/// will return the count of all rows in the table.
Future<int> count(
_is.DatabaseSession session, {
_is.WhereExpressionBuilder<TrainingPlaceTable>? where,
int? limit,
_is.Transaction? transaction,
}) async {
return session.db.count<TrainingPlace>(
where: where?.call(TrainingPlace.t),
limit: limit,
transaction: transaction,
);
}
/// Acquires row-level locks on [TrainingPlace] rows matching the [where] expression.
Future<void> lockRows(
_is.DatabaseSession session, {
required _is.WhereExpressionBuilder<TrainingPlaceTable> where,
required _is.LockMode lockMode,
required _is.Transaction transaction,
_is.LockBehavior lockBehavior = _is.LockBehavior.wait,
}) async {
return session.db.lockRows<TrainingPlace>(
where: where(TrainingPlace.t),
lockMode: lockMode,
lockBehavior: lockBehavior,
transaction: transaction,
);
}
}

84
apps/train/halkyon_train_server/lib/src/generated/protocol.dart
View file

@ -28,6 +28,7 @@ import 'package:serverpod_offline_sync_server/serverpod_offline_sync_server.dart
import 'day/day.dart' as _ikmv9f3y;
import 'day/day_series.dart' as _ir1ofny6;
import 'day/night.dart' as _i17cgxdf;
import 'equipment/training_place.dart' as _icbb9j80;
import 'firmware/loop_firmware.dart' as _i4qollgq;
import 'firmware/loop_firmware_refused.dart' as _ipcwdy0l;
import 'map/map_source.dart' as _ikw0qg8x;
@ -48,6 +49,7 @@ import 'workout/workout_series.dart' as _i92mefto;
export 'day/day.dart';
export 'day/day_series.dart';
export 'day/night.dart';
export 'equipment/training_place.dart';
export 'firmware/loop_firmware.dart';
export 'firmware/loop_firmware_refused.dart';
export 'map/map_source.dart';
@ -568,6 +570,73 @@ class Protocol extends _is.DatabaseSerializationManager {
],
managed: true,
),
_isp.TableDefinition(
name: 'training_place',
dartName: 'TrainingPlace',
schema: 'public',
module: 'halkyon_train',
columns: [
_isp.ColumnDefinition(
name: 'id',
columnType: _isp.ColumnType.uuid,
isNullable: false,
dartType: 'UuidValue?',
columnDefault: 'random_v7',
),
_isp.ColumnDefinition(
name: 'spaceId',
columnType: _isp.ColumnType.bigint,
isNullable: true,
dartType: 'int?',
),
_isp.ColumnDefinition(
name: 'keyId',
columnType: _isp.ColumnType.text,
isNullable: true,
dartType: 'String?',
),
_isp.ColumnDefinition(
name: 'payload',
columnType: _isp.ColumnType.bytea,
isNullable: false,
dartType: 'dart:typed_data:ByteData',
),
_isp.ColumnDefinition(
name: 'nonce',
columnType: _isp.ColumnType.bytea,
isNullable: true,
dartType: 'dart:typed_data:ByteData?',
),
],
foreignKeys: [
_isp.ForeignKeyDefinition(
constraintName: 'training_place_fk_0',
columns: ['spaceId'],
referenceTable: 'offline_sync_spaces',
referenceTableSchema: 'public',
referenceColumns: ['id'],
onUpdate: _isp.ForeignKeyAction.noAction,
onDelete: _isp.ForeignKeyAction.cascade,
matchType: null,
),
],
indexes: [
_isp.IndexDefinition(
indexName: 'training_place_space_idx',
tableSpace: null,
elements: [
_isp.IndexElementDefinition(
type: _isp.IndexElementDefinitionType.column,
definition: 'spaceId',
),
],
type: 'btree',
isUnique: false,
isPrimary: false,
),
],
managed: true,
),
_isp.TableDefinition(
name: 'workout',
dartName: 'Workout',
@ -776,6 +845,9 @@ class Protocol extends _is.DatabaseSerializationManager {
if (t == _i17cgxdf.Night) {
return _i17cgxdf.Night.fromJson(data) as T;
}
if (t == _icbb9j80.TrainingPlace) {
return _icbb9j80.TrainingPlace.fromJson(data) as T;
}
if (t == _i4qollgq.LoopFirmware) {
return _i4qollgq.LoopFirmware.fromJson(data) as T;
}
@ -836,6 +908,10 @@ class Protocol extends _is.DatabaseSerializationManager {
if (t == _is.getType<_i17cgxdf.Night?>()) {
return (data != null ? _i17cgxdf.Night.fromJson(data) : null) as T;
}
if (t == _is.getType<_icbb9j80.TrainingPlace?>()) {
return (data != null ? _icbb9j80.TrainingPlace.fromJson(data) : null)
as T;
}
if (t == _is.getType<_i4qollgq.LoopFirmware?>()) {
return (data != null ? _i4qollgq.LoopFirmware.fromJson(data) : null) as T;
}
@ -949,6 +1025,7 @@ class Protocol extends _is.DatabaseSerializationManager {
_ikmv9f3y.Day => 'Day',
_ir1ofny6.DaySeries => 'DaySeries',
_i17cgxdf.Night => 'Night',
_icbb9j80.TrainingPlace => 'TrainingPlace',
_i4qollgq.LoopFirmware => 'LoopFirmware',
_ipcwdy0l.LoopFirmwareRefused => 'LoopFirmwareRefused',
_ikw0qg8x.MapSource => 'MapSource',
@ -989,6 +1066,8 @@ class Protocol extends _is.DatabaseSerializationManager {
return 'DaySeries';
case _i17cgxdf.Night():
return 'Night';
case _icbb9j80.TrainingPlace():
return 'TrainingPlace';
case _i4qollgq.LoopFirmware():
return 'LoopFirmware';
case _ipcwdy0l.LoopFirmwareRefused():
@ -1072,6 +1151,9 @@ class Protocol extends _is.DatabaseSerializationManager {
if (dataClassName == 'Night') {
return deserialize<_i17cgxdf.Night>(data['data']);
}
if (dataClassName == 'TrainingPlace') {
return deserialize<_icbb9j80.TrainingPlace>(data['data']);
}
if (dataClassName == 'LoopFirmware') {
return deserialize<_i4qollgq.LoopFirmware>(data['data']);
}
@ -1203,6 +1285,8 @@ class Protocol extends _is.DatabaseSerializationManager {
return _ir1ofny6.DaySeries.t;
case _i17cgxdf.Night:
return _i17cgxdf.Night.t;
case _icbb9j80.TrainingPlace:
return _icbb9j80.TrainingPlace.t;
case _i45prw73.Plan:
return _i45prw73.Plan.t;
case _imed3x5d.ContentKey:

2
apps/train/halkyon_train_server/lib/src/generated/sync_tables.dart
View file

@ -14,6 +14,7 @@ import 'package:serverpod/serverpod.dart' as _is;
import 'day/day.dart' as _ikmv9f3y;
import 'day/day_series.dart' as _ir1ofny6;
import 'day/night.dart' as _i17cgxdf;
import 'equipment/training_place.dart' as _icbb9j80;
import 'plan/plan.dart' as _i45prw73;
import 'privacy/content_key.dart' as _imed3x5d;
import 'profile/profile.dart' as _ia5j8fch;
@ -32,6 +33,7 @@ final List<_is.Table> syncTables = [
_i45prw73.Plan.t,
_ia5j8fch.Profile.t,
_i0mgeh8t.SavedRoute.t,
_icbb9j80.TrainingPlace.t,
_i5b9b17z.Workout.t,
_i92mefto.WorkoutSeries.t,
];