repo_id
stringlengths 21
168
| file_path
stringlengths 36
210
| content
stringlengths 1
9.98M
| __index_level_0__
int64 0
0
|
|---|---|---|---|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/delete_exercise.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
class DeleteExercise extends StatelessWidget {
const DeleteExercise({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseLogsDetailsBloc,
WorkoutExerciseLogsDetailsState>(
builder: (context, state) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: DeleteButton(
text: context.locale.deleteExercise,
dialogText:
context.locale.deleteText(state.exerciseLog!.exercise.name),
onConfirm: () => context.read<WorkoutExerciseLogsDetailsBloc>().add(
const WorkoutExerciseLogsDetailsDelete(),
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/series_item.dart
|
import 'package:future_of_workout/src/app/bloc/app_bloc.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
import 'package:workout_log_api/workout_log_api.dart';
class SeriesItem extends StatelessWidget {
const SeriesItem({super.key, required this.series, this.isClickable = false});
final ExerciseSeriesLog series;
final bool isClickable;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AbsorbPointer(
absorbing: !isClickable,
child: DecoratedBox(
decoration: BoxDecoration(
color: isClickable ? null : AppColors.grey.withOpacity(0.25),
borderRadius: BorderRadius.circular(16),
),
child: ExerciseSeriesLogItem(
series: series,
onTap: () async {
final bloc = context.read<WorkoutExerciseLogsDetailsBloc>();
final unit = context.read<AppBloc>().state.user!.weightUnit;
final title = series.isFinished
? context.locale.updateSeries
: context.locale.completeSeries;
await showDialog<void>(
context: context,
builder: (builderContext) => SeriesLogDialog(
title: title,
weight: UnitConverter.dispalyedWeight(
unit: unit,
value: series.weight,
).toString(),
reps: series.reps.toString(),
intensity: series.intensity,
onConfirm: (reps, weight, intensity) {
final value =
UnitConverter.dataWeight(unit: unit, value: weight);
bloc.add(
WorkoutExerciseLogsDetailsUpdateSeries(
seriesLog: series.copyWith(
weight: value,
reps: reps,
intensity: intensity,
isFinished: true,
),
),
);
},
),
);
},
),
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/series_list.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
import 'package:workout_log_api/workout_log_api.dart';
class SeriesList extends StatelessWidget {
const SeriesList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseLogsDetailsBloc,
WorkoutExerciseLogsDetailsState>(
buildWhen: (previous, current) =>
previous.exerciseLog!.exerciseSeriesLogs !=
current.exerciseLog!.exerciseSeriesLogs,
builder: (context, state) {
final logs = state.exerciseLog!.exerciseSeriesLogs;
ExerciseSeriesLog? previousSeries;
return Column(
children: logs.map<Widget>((series) {
final item = SeriesItem(
series: series,
isClickable: previousSeries?.isFinished ?? true,
);
previousSeries = series;
return item;
}).toList(),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/widgets.dart
|
export 'add_series.dart';
export 'delete_exercise.dart';
export 'remove_series.dart';
export 'series_item.dart';
export 'series_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/remove_series.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
class RemoveSeries extends StatelessWidget {
const RemoveSeries({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseLogsDetailsBloc,
WorkoutExerciseLogsDetailsState>(
buildWhen: (previous, current) =>
previous.exerciseLog?.exerciseSeriesLogs !=
current.exerciseLog?.exerciseSeriesLogs,
builder: (context, state) {
return Visibility(
visible: state.exerciseLog?.exerciseSeriesLogs.isNotEmpty ?? false,
child: Padding(
padding: const EdgeInsets.only(bottom: 8),
child: ListRemoveButton(
text: context.locale.deleteSeries,
dialogText: context.locale.deleteSeriesText,
onConfirm: () async {
context
.read<WorkoutExerciseLogsDetailsBloc>()
.add(const WorkoutExerciseLogsDetailsRemoveSeries());
},
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/view/widgets/add_series.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
import 'package:workout_api/workout_api.dart';
import 'package:workout_log_api/workout_log_api.dart';
class AddSeries extends StatelessWidget {
const AddSeries({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseLogsDetailsBloc,
WorkoutExerciseLogsDetailsState>(
buildWhen: (previous, current) =>
current.exerciseLog?.isFinished ?? false,
builder: (context, state) {
return Visibility(
visible: state.exerciseLog?.isFinished ?? false,
child: Padding(
padding: const EdgeInsets.only(bottom: 8),
child: ListAddButton(
text: context.locale.addSeries,
onTap: () async {
final bloc = context.read<WorkoutExerciseLogsDetailsBloc>();
ExerciseSeriesLog last;
try {
last = state.exerciseLog!.exerciseSeriesLogs.last;
} catch (_) {
last = ExerciseSeriesLog.fromExerciseSeries(
ExerciseSeries(index: 0),
);
}
await showDialog<void>(
context: context,
builder: (builderContext) => SeriesLogDialog(
title: context.locale.completeSeries,
weight: last.weight.toString(),
reps: last.reps.toString(),
intensity: last.intensity,
onConfirm: (reps, weight, intensity) {
bloc.add(
WorkoutExerciseLogsDetailsAddSeries(
seriesLog: ExerciseSeriesLog(
index: last.index + 1,
rest: last.rest,
isFinished: true,
weight: weight,
reps: reps,
intensity: intensity,
),
),
);
},
),
);
},
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/bloc/workout_exercise_logs_details_event.dart
|
part of 'workout_exercise_logs_details_bloc.dart';
abstract class WorkoutExerciseLogsDetailsEvent extends Equatable {
const WorkoutExerciseLogsDetailsEvent();
@override
List<Object> get props => [];
}
class WorkoutExerciseLogsDetailsSubscriptionRequest
extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsSubscriptionRequest({
required this.workoutLogId,
required this.workoutExerciseLogId,
});
final String workoutLogId;
final String workoutExerciseLogId;
@override
List<Object> get props => [workoutExerciseLogId, workoutLogId];
}
class WorkoutExerciseLogsDetailsPop extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsPop();
}
class WorkoutExerciseLogsDetailsUpdateSeries
extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsUpdateSeries({required this.seriesLog});
final ExerciseSeriesLog seriesLog;
@override
List<Object> get props => [seriesLog];
}
class WorkoutExerciseLogsDetailsAddSeries
extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsAddSeries({required this.seriesLog});
final ExerciseSeriesLog seriesLog;
@override
List<Object> get props => [seriesLog];
}
class WorkoutExerciseLogsDetailsRemoveSeries
extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsRemoveSeries();
}
class WorkoutExerciseLogsDetailsDelete extends WorkoutExerciseLogsDetailsEvent {
const WorkoutExerciseLogsDetailsDelete();
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/bloc/workout_exercise_logs_details_state.dart
|
part of 'workout_exercise_logs_details_bloc.dart';
enum WorkoutExerciseLogsDetailsStatus {
initial,
loading,
loaded,
updated,
deleting,
deleted,
failure,
}
class WorkoutExerciseLogsDetailsState extends Equatable {
const WorkoutExerciseLogsDetailsState({
this.status = WorkoutExerciseLogsDetailsStatus.initial,
this.exerciseLog,
this.workoutLog,
});
final WorkoutExerciseLogsDetailsStatus status;
final WorkoutExerciseLog? exerciseLog;
final WorkoutLog? workoutLog;
@override
List<Object?> get props => [status, exerciseLog, workoutLog];
WorkoutExerciseLogsDetailsState copyWith({
WorkoutExerciseLogsDetailsStatus? status,
WorkoutExerciseLog? exerciseLog,
WorkoutLog? workoutLog,
}) {
return WorkoutExerciseLogsDetailsState(
status: status ?? this.status,
exerciseLog: exerciseLog ?? this.exerciseLog,
workoutLog: workoutLog ?? this.workoutLog,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_exercise_logs_details/bloc/workout_exercise_logs_details_bloc.dart
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
part 'workout_exercise_logs_details_event.dart';
part 'workout_exercise_logs_details_state.dart';
class WorkoutExerciseLogsDetailsBloc extends Bloc<
WorkoutExerciseLogsDetailsEvent, WorkoutExerciseLogsDetailsState> {
WorkoutExerciseLogsDetailsBloc({
required WorkoutLogRepository workoutLogRepository,
}) : _repository = workoutLogRepository,
super(const WorkoutExerciseLogsDetailsState()) {
on<WorkoutExerciseLogsDetailsSubscriptionRequest>(_onSubscriptionRequest);
on<WorkoutExerciseLogsDetailsPop>(_onPop);
on<WorkoutExerciseLogsDetailsUpdateSeries>(_onUpdateSeries);
on<WorkoutExerciseLogsDetailsAddSeries>(_onAddSeries);
on<WorkoutExerciseLogsDetailsRemoveSeries>(_onRemoveSeries);
on<WorkoutExerciseLogsDetailsDelete>(_onDelete);
}
final WorkoutLogRepository _repository;
Future<void> _onSubscriptionRequest(
WorkoutExerciseLogsDetailsSubscriptionRequest event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) async {
emit(state.copyWith(status: WorkoutExerciseLogsDetailsStatus.loading));
final log = _repository.get(id: event.workoutLogId);
final exerciseLog = log.workoutExerciseLogs
.firstWhere((element) => element.id == event.workoutExerciseLogId);
emit(
state.copyWith(
status: WorkoutExerciseLogsDetailsStatus.loaded,
exerciseLog: exerciseLog,
workoutLog: log,
),
);
}
Future<void> _onPop(
WorkoutExerciseLogsDetailsPop event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) async {
if (state.status == WorkoutExerciseLogsDetailsStatus.updated) {
final workoutLog = state.workoutLog!;
final exerciseLog = state.exerciseLog!;
final exerciseIndex = workoutLog.workoutExerciseLogs
.indexWhere((element) => element.id == exerciseLog.id);
final logs = List.of(workoutLog.workoutExerciseLogs);
logs[exerciseIndex] = exerciseLog;
final log = workoutLog.copyWith(workoutExerciseLogs: logs);
await _repository.saveWorkoutLog(workoutLog: log);
}
}
void _onUpdateSeries(
WorkoutExerciseLogsDetailsUpdateSeries event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) {
final exerciseLog = state.exerciseLog!;
final seriesIndex = exerciseLog.exerciseSeriesLogs
.indexWhere((series) => series.id == event.seriesLog.id);
final logs = List.of(exerciseLog.exerciseSeriesLogs);
logs[seriesIndex] = event.seriesLog;
final complete = !logs.any((log) => !log.isFinished);
final log =
exerciseLog.copyWith(exerciseSeriesLogs: logs, isFinished: complete);
emit(
state.copyWith(
status: WorkoutExerciseLogsDetailsStatus.updated,
exerciseLog: log,
),
);
}
void _onAddSeries(
WorkoutExerciseLogsDetailsAddSeries event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) {
final exerciseLog = state.exerciseLog!;
final logs = List.of(exerciseLog.exerciseSeriesLogs)..add(event.seriesLog);
final log = exerciseLog.copyWith(exerciseSeriesLogs: logs);
emit(
state.copyWith(
status: WorkoutExerciseLogsDetailsStatus.updated,
exerciseLog: log,
),
);
}
void _onRemoveSeries(
WorkoutExerciseLogsDetailsRemoveSeries event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) {
final exerciseLog = state.exerciseLog!;
final logs = List.of(exerciseLog.exerciseSeriesLogs);
final last = logs.last;
logs.remove(last);
final log = exerciseLog.copyWith(exerciseSeriesLogs: logs);
emit(
state.copyWith(
status: WorkoutExerciseLogsDetailsStatus.updated,
exerciseLog: log,
),
);
}
Future<void> _onDelete(
WorkoutExerciseLogsDetailsDelete event,
Emitter<WorkoutExerciseLogsDetailsState> emit,
) async {
try {
emit(state.copyWith(status: WorkoutExerciseLogsDetailsStatus.deleting));
final workoutExerciseLogs =
List.of(state.workoutLog!.workoutExerciseLogs);
final index = workoutExerciseLogs
.indexWhere((element) => element.id == state.exerciseLog!.id);
workoutExerciseLogs.removeAt(index);
final workoutLog =
state.workoutLog!.copyWith(workoutExerciseLogs: workoutExerciseLogs);
await _repository.saveWorkoutLog(workoutLog: workoutLog);
emit(state.copyWith(status: WorkoutExerciseLogsDetailsStatus.deleted));
} catch (e) {
emit(state.copyWith(status: WorkoutExerciseLogsDetailsStatus.failure));
}
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/workout_logs.dart
|
export 'bloc/workout_logs_bloc.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view/view.dart
|
export 'widgets/widgets.dart';
export 'workout_logs_tab.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view/workout_logs_tab.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
class WorkoutsLogsTab extends StatelessWidget {
const WorkoutsLogsTab({super.key});
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) => WorkoutLogsBloc(
workoutLogRepository: context.read<WorkoutLogRepository>(),
)..add(const WorkoutLogsLoadingRequest()),
child: const WorkoutsLogsView(),
);
}
}
class WorkoutsLogsView extends StatelessWidget {
const WorkoutsLogsView({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutLogsBloc, WorkoutLogsState>(
buildWhen: (previous, current) => previous.status != current.status,
builder: (context, state) {
switch (state.status) {
case WorkoutLogsStatus.initial:
case WorkoutLogsStatus.loading:
return const AppScaffold(body: AppLoading());
case WorkoutLogsStatus.loaded:
return const WorkoutLogsList();
case WorkoutLogsStatus.empty:
return AppScaffold(
body: AppEmptyList(
text: context.locale.workoutLogsListEmpty,
),
);
case WorkoutLogsStatus.failure:
return const AppScaffold(body: AppError());
}
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view/widgets/workout_log_item.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:intl/intl.dart';
import 'package:workout_log_api/workout_log_api.dart';
class WorkoutLogItem extends StatelessWidget {
const WorkoutLogItem({
super.key,
required this.log,
this.isReverse = false,
this.onTap,
});
final WorkoutLog log;
final bool isReverse;
final VoidCallback? onTap;
@override
Widget build(BuildContext context) {
return LayoutBuilder(
builder: (context, constraints) {
return CustomCard(
key: Key('workout_log_item_${log.id}'),
onTap: onTap,
child: ClipRRect(
borderRadius: BorderRadius.circular(16),
child: Row(
children: _getContent(constraints.maxWidth / 2, context),
),
),
);
},
);
}
List<Widget> _getContent(double size, BuildContext context) {
final list = [
Align(
alignment: isReverse ? Alignment.topRight : Alignment.topLeft,
child: _getData(size, context),
),
_getBody(size),
];
if (isReverse) {
return list.reversed.toList();
}
return list;
}
Widget _getData(double size, BuildContext context) {
return SizedBox(
width: size,
child: Padding(
padding: const EdgeInsets.symmetric(
horizontal: 16,
vertical: 8,
),
child: Column(
crossAxisAlignment:
isReverse ? CrossAxisAlignment.end : CrossAxisAlignment.start,
children: [
Text(log.name, style: AppTextStyle.bold24),
const SizedBox(height: 16),
_buildDate(context),
const SizedBox(height: 8),
_buildTime(),
const SizedBox(height: 8),
_buildExercises(context),
const SizedBox(height: 8),
],
),
),
);
}
Widget _getBody(double size) {
return BodyContainer(
size: size,
body: log.body(),
);
}
Widget _buildDate(BuildContext context) {
final formatter = DateFormat(
'dd MMM',
context.languageCode,
);
final text = BoldText(
boldText: formatter.format(log.startDate),
);
return _buildRow(
text: text,
icon: const AppIcon(iconData: AppIcons.calendar),
);
}
Widget _buildTime() {
final time = log.endDate!.difference(log.startDate);
final text = BoldText(
boldText: '${time.inMinutes} ',
mediumText: 'min',
);
return _buildRow(
text: text,
icon: const AppIcon(iconData: AppIcons.clock),
);
}
Widget _buildExercises(BuildContext context) {
final exercises = log.workoutExerciseLogs
.where(
(exercise) =>
exercise.exerciseSeriesLogs.any((series) => series.isFinished),
)
.toList()
.length;
final text = BoldText(
boldText: '$exercises ',
mediumText: context.locale.exercisesCount(exercises),
);
return _buildRow(
text: text,
icon: const AppIcon(iconData: AppIcons.gym),
);
}
Widget _buildRow({
required Widget text,
required Widget icon,
}) {
final children = [
text,
const SizedBox(width: 8),
icon,
];
return Row(
mainAxisAlignment:
isReverse ? MainAxisAlignment.end : MainAxisAlignment.start,
textBaseline: TextBaseline.alphabetic,
children: isReverse ? children : children.reversed.toList(),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view/widgets/widgets.dart
|
export 'workout_log_item.dart';
export 'workout_logs_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/view/widgets/workout_logs_list.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout_logs/workout_logs.dart';
import 'package:future_of_workout/src/workout/workouts/workouts.dart';
import 'package:go_router/go_router.dart';
class WorkoutLogsList extends StatelessWidget {
const WorkoutLogsList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutLogsBloc, WorkoutLogsState>(
buildWhen: (previous, current) => previous.logs != current.logs,
builder: (context, state) {
return ListView.separated(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
separatorBuilder: (context, index) => const SizedBox(height: 8),
physics: const BouncingScrollPhysics(),
itemCount: state.logs.length,
itemBuilder: (context, index) {
final item = state.logs[index];
return WorkoutLogItem(
log: item,
isReverse: index.isOdd,
onTap: () {
context.goNamed(
WorkoutLogsDetailsPage.name,
params: {
'homePageTab': WorkoutsPage.name,
'workoutLogId': item.id,
},
);
},
);
},
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/bloc/workout_logs_state.dart
|
part of 'workout_logs_bloc.dart';
enum WorkoutLogsStatus {
initial,
loading,
loaded,
empty,
failure,
}
class WorkoutLogsState extends Equatable {
const WorkoutLogsState({
this.status = WorkoutLogsStatus.initial,
this.logs = const [],
});
final WorkoutLogsStatus status;
final List<WorkoutLog> logs;
@override
List<Object> get props => [status, logs];
WorkoutLogsState copyWith({
WorkoutLogsStatus? status,
List<WorkoutLog>? logs,
}) {
return WorkoutLogsState(
status: status ?? this.status,
logs: logs ?? this.logs,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/bloc/workout_logs_event.dart
|
part of 'workout_logs_bloc.dart';
abstract class WorkoutLogsEvent extends Equatable {
const WorkoutLogsEvent();
@override
List<Object> get props => [];
}
class WorkoutLogsLoadingRequest extends WorkoutLogsEvent{
const WorkoutLogsLoadingRequest();
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs
|
mirrored_repositories/future_of_workout/lib/src/workout/workout_logs/workout_logs/bloc/workout_logs_bloc.dart
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
part 'workout_logs_event.dart';
part 'workout_logs_state.dart';
class WorkoutLogsBloc extends Bloc<WorkoutLogsEvent, WorkoutLogsState> {
WorkoutLogsBloc({required WorkoutLogRepository workoutLogRepository})
: _repository = workoutLogRepository,
super(const WorkoutLogsState()) {
on<WorkoutLogsLoadingRequest>(_onLoadingRequest);
}
final WorkoutLogRepository _repository;
Future<void> _onLoadingRequest(
WorkoutLogsLoadingRequest event,
Emitter<WorkoutLogsState> emit,
) async {
emit(state.copyWith(status: WorkoutLogsStatus.loading));
await emit.forEach<List<WorkoutLog>>(
_repository.getWorkoutLogs(),
onData: (logs) {
logs.removeWhere((element) => element.endDate == null);
if (logs.isEmpty) {
return state.copyWith(status: WorkoutLogsStatus.empty);
}
logs.sort(
(a, b) => b.startDate.compareTo(a.startDate),
);
return state.copyWith(status: WorkoutLogsStatus.loaded, logs: logs);
},
onError: (_, __) => state.copyWith(status: WorkoutLogsStatus.failure),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout.dart
|
export 'workout_details/workout_details.dart';
export 'workout_exercise_details/workout_exercise_details.dart';
export 'workout_list/workout_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/workout_list.dart
|
export 'bloc/workout_list_bloc.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/view.dart
|
export 'workouts_list_tab.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/workouts_list_tab.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:future_of_workout/src/workout/workout/workout_list/view/widgets/widgets.dart';
import 'package:future_of_workout/src/workout/workouts/workouts.dart';
import 'package:go_router/go_router.dart';
import 'package:user_repository/user_repository.dart';
import 'package:workout_repository/workout_repository.dart';
class WorkoutsListTab extends StatelessWidget {
const WorkoutsListTab({super.key});
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) {
return WorkoutListBloc(
workoutRepository: context.read<WorkoutRepository>(),
userRepository: context.read<UserRepository>(),
)..add(const WorkoutListLoadingUser());
},
child: const _WorkoutListView(),
);
}
}
class _WorkoutListView extends StatelessWidget {
const _WorkoutListView();
@override
Widget build(BuildContext context) {
return AppScaffold(
floatingActionButton: const AddWorkout(),
body: ListView(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: [
const StartWorkout(),
BlocConsumer<WorkoutListBloc, WorkoutListState>(
listenWhen: (previous, current) =>
previous.status != current.status,
listener: (context, state) {
if (state.status == WorkoutListStatus.loadedUser) {
context.read<WorkoutListBloc>().add(const WorkoutListLoading());
}
if (state.status == WorkoutListStatus.added) {
context.goNamed(
WorkoutDetailsPage.name,
params: {
'homePageTab': WorkoutsPage.name,
'workoutId': state.newWorkoutId,
},
);
}
},
builder: (context, state) {
switch (state.status) {
case WorkoutListStatus.initial:
case WorkoutListStatus.loadingUser:
case WorkoutListStatus.loadedUser:
case WorkoutListStatus.loadingPlan:
return const AppLoading();
case WorkoutListStatus.failure:
return const AppError();
case WorkoutListStatus.empty:
return AppEmptyList(
text: context.locale.workoutListEmpty,
);
case WorkoutListStatus.noSelectedPlan:
return AppEmptyList(
text: context.locale.noSelectedPlan,
);
case WorkoutListStatus.added:
case WorkoutListStatus.loadedPlan:
return const WorkoutList();
}
},
),
],
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/new_workout_dialog.dart
|
import 'package:future_of_workout/src/common.dart';
class NewWorkoutDialog extends StatelessWidget {
const NewWorkoutDialog({required this.onConfirm, super.key});
final ValueChanged<String> onConfirm;
@override
Widget build(BuildContext context) {
final controller = TextEditingController();
return CustomDialog(
title: context.locale.newWorkout,
content: TextField(
controller: controller,
style: AppTextStyle.bold28,
decoration: InputDecoration(
hintText: context.locale.name,
),
),
confirmButtonText: context.locale.add,
onConfirm: () {
final name = controller.text;
onConfirm(name);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/workouts_list.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:future_of_workout/src/workout/workout/workout_list/view/widgets/widgets.dart';
import 'package:future_of_workout/src/workout/workouts/workouts.dart';
import 'package:go_router/go_router.dart';
class WorkoutList extends StatelessWidget {
const WorkoutList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutListBloc, WorkoutListState>(
buildWhen: (previous, current) =>
previous.plan?.workouts != current.plan?.workouts,
builder: (context, state) {
final list = state.plan!.workouts;
// TODO(UI): Draggable list
return Column(
children: list.map<Widget>((workout) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: WorkoutItem(
workout: workout,
isReverse: list.indexOf(workout).isOdd,
onTap: () {
context.goNamed(
WorkoutDetailsPage.name,
params: {
'homePageTab': WorkoutsPage.name,
'workoutId': workout.id,
},
);
},
),
);
}).toList(),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/start_workout.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/current_workout/current_workout.dart';
import 'package:future_of_workout/src/home/home.dart';
import 'package:go_router/go_router.dart';
class StartWorkout extends StatelessWidget {
const StartWorkout({super.key});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: StartButton(
text: context.locale.startWorkoutButtonText,
onTap: () {
context
.read<CurrentWorkoutBloc>()
.add(const CurrentWorkoutStartWorkout());
context.goNamed(
HomePage.name,
params: {'homePageTab': CurrentWorkoutPage.name},
);
},
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/widgets.dart
|
export 'add_workout.dart';
export 'new_workout_dialog.dart';
export 'start_workout.dart';
export 'workout_item.dart';
export 'workouts_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/add_workout.dart
|
import 'package:flutter_speed_dial/flutter_speed_dial.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/plan_selection/plan_selection_page.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:future_of_workout/src/workout/workout/workout_list/view/widgets/widgets.dart';
import 'package:go_router/go_router.dart';
class AddWorkout extends StatelessWidget {
const AddWorkout({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutListBloc, WorkoutListState>(
buildWhen: (previous, current) =>
previous.currentPlanId != current.currentPlanId,
builder: (context, state) {
return SpeedDial(
overlayColor: AppColors.grey,
overlayOpacity: 0.4,
children: [
_addWorkout(context, isVisible: state.currentPlanId != null),
_selectPlan(context),
],
spacing: 4,
activeChild: const AppIcon(iconData: AppIcons.minus),
child: const AppIcon(iconData: AppIcons.plus),
);
},
);
}
SpeedDialChild _addWorkout(BuildContext context, {required bool isVisible}) {
return SpeedDialChild(
visible: isVisible,
// TODO(intl): Translate
label: 'Add workout',
child: const AppIcon(iconData: AppIcons.plus),
onTap: () async {
final bloc = context.read<WorkoutListBloc>();
await showDialog<String>(
context: context,
builder: (context) => NewWorkoutDialog(
onConfirm: (name) =>
bloc.add(WorkoutListNewWorkoutAdding(name: name)),
),
);
},
);
}
SpeedDialChild _selectPlan(BuildContext context) {
return SpeedDialChild(
// TODO(intl): Translate
label: 'Select plan',
child: const AppIcon(iconData: AppIcons.listAdd),
onTap: () {
context.goNamed(
PlanSelectionPage.name,
params: PlanSelectionPage.params,
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/view/widgets/workout_item.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:workout_api/workout_api.dart';
class WorkoutItem extends StatelessWidget {
const WorkoutItem({
super.key,
required this.workout,
this.isReverse = false,
this.onTap,
});
final Workout workout;
final VoidCallback? onTap;
final bool isReverse;
@override
Widget build(BuildContext context) {
return LayoutBuilder(
builder: (context, constraints) {
return CustomCard(
key: Key('workout_log_item_${workout.id}'),
onTap: onTap,
child: ClipRRect(
borderRadius: BorderRadius.circular(16),
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: _getContent(constraints.maxWidth / 2, context),
),
),
);
},
);
}
List<Widget> _getContent(double size, BuildContext context) {
final list = [
Align(
alignment: isReverse ? Alignment.topRight : Alignment.topLeft,
child: _getData(size, context),
),
_getBody(size * 0.8),
];
if (isReverse) {
return list.reversed.toList();
}
return list;
}
Widget _getData(double size, BuildContext context) {
return SizedBox(
width: size,
child: Padding(
padding: const EdgeInsets.symmetric(
horizontal: 16,
vertical: 8,
),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment:
isReverse ? CrossAxisAlignment.end : CrossAxisAlignment.start,
children: [
Text(workout.name, style: AppTextStyle.bold24),
const SizedBox(height: 16),
_buildExercises(context),
const SizedBox(height: 8),
],
),
),
);
}
Widget _getBody(double size) {
return BodyContainer(
size: size,
body: workout.body(),
);
}
Widget _buildExercises(BuildContext context) {
final exercises = workout.workoutExercises.length;
final text = _buildText(
bold: '$exercises ',
medium: context.locale.exercisesCount(exercises),
);
return _buildRow(
text: text,
icon: const AppIcon(iconData: AppIcons.gym),
);
}
Widget _buildRow({
required Widget text,
required Widget icon,
}) {
final children = [
text,
const SizedBox(width: 8),
icon,
];
return Row(
mainAxisAlignment:
isReverse ? MainAxisAlignment.end : MainAxisAlignment.start,
textBaseline: TextBaseline.alphabetic,
children: isReverse ? children : children.reversed.toList(),
);
}
Widget _buildText({required String bold, String medium = ''}) {
return RichText(
text: TextSpan(
children: [
TextSpan(text: bold, style: AppTextStyle.semiBold20),
TextSpan(text: medium, style: AppTextStyle.medium16),
],
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/bloc/workout_list_event.dart
|
part of 'workout_list_bloc.dart';
abstract class WorkoutListEvent extends Equatable {
const WorkoutListEvent();
@override
List<Object?> get props => [];
}
class WorkoutListLoadingUser extends WorkoutListEvent {
const WorkoutListLoadingUser();
}
class WorkoutListLoading extends WorkoutListEvent {
const WorkoutListLoading();
}
class WorkoutListNewWorkoutAdding extends WorkoutListEvent {
const WorkoutListNewWorkoutAdding({required this.name});
final String name;
@override
List<Object?> get props => [name];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/bloc/workout_list_state.dart
|
part of 'workout_list_bloc.dart';
enum WorkoutListStatus {
initial,
loadingUser,
loadedUser,
loadingPlan,
loadedPlan,
noSelectedPlan,
empty,
added,
failure,
}
class WorkoutListState extends Equatable {
const WorkoutListState({
this.status = WorkoutListStatus.initial,
this.currentPlanId,
this.plan,
this.newWorkoutId = '',
});
final WorkoutListStatus status;
final String? currentPlanId;
final Plan? plan;
final String newWorkoutId;
@override
List<Object?> get props => [status, plan, newWorkoutId, currentPlanId];
WorkoutListState copyWith({
WorkoutListStatus? status,
String? Function()? currentPlanId,
Plan? Function()? plan,
String? newWorkoutId,
}) {
return WorkoutListState(
status: status ?? this.status,
plan: plan != null ? plan() : this.plan,
newWorkoutId: newWorkoutId ?? this.newWorkoutId,
currentPlanId:
currentPlanId != null ? currentPlanId() : this.currentPlanId,
);
}
@override
String toString() {
final map = {
'status': status,
'currentPlanId': currentPlanId,
'plan': plan?.id,
};
return map.toString();
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_list/bloc/workout_list_bloc.dart
|
import 'dart:async';
import 'package:equatable/equatable.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:user_repository/user_repository.dart';
import 'package:workout_repository/workout_repository.dart';
part 'workout_list_state.dart';
part 'workout_list_event.dart';
class WorkoutListBloc extends Bloc<WorkoutListEvent, WorkoutListState> {
WorkoutListBloc({
required WorkoutRepository workoutRepository,
required UserRepository userRepository,
}) : _workoutRepository = workoutRepository,
_userRepository = userRepository,
super(const WorkoutListState()) {
on<WorkoutListLoadingUser>(_onLoadingUser);
on<WorkoutListLoading>(_onLoading);
on<WorkoutListNewWorkoutAdding>(_onNewWorkoutAdding);
}
final WorkoutRepository _workoutRepository;
final UserRepository _userRepository;
Future<void> _onLoadingUser(
WorkoutListLoadingUser event,
Emitter<WorkoutListState> emit,
) async {
emit(state.copyWith(status: WorkoutListStatus.loadingUser));
await emit.forEach<User?>(
_userRepository.getUser(),
onData: (user) {
if (user?.currentPlanId == null) {
return state.copyWith(
status: WorkoutListStatus.noSelectedPlan,
plan: () => null,
);
}
return state.copyWith(
status: WorkoutListStatus.loadedUser,
currentPlanId: () => user?.currentPlanId,
);
},
onError: (_, __) => state.copyWith(status: WorkoutListStatus.failure),
);
}
Future<void> _onLoading(
WorkoutListLoading event,
Emitter<WorkoutListState> emit,
) async {
emit(state.copyWith(status: WorkoutListStatus.loadingPlan));
final planId = state.currentPlanId;
if (planId == null) {
emit(state.copyWith(status: WorkoutListStatus.failure));
return;
}
await emit.forEach<Plan?>(
_workoutRepository.getPlanStream(id: state.currentPlanId!),
onData: (plan) {
if (plan == null) {
return state.copyWith(
status: WorkoutListStatus.noSelectedPlan,
plan: () => null,
);
}
if (plan.workouts.isEmpty) {
return state.copyWith(
status: WorkoutListStatus.empty,
plan: () => plan,
);
}
return state.copyWith(
status: WorkoutListStatus.loadedPlan,
plan: () => plan,
);
},
onError: (_, __) => state.copyWith(status: WorkoutListStatus.failure),
);
}
Future<void> _onNewWorkoutAdding(
WorkoutListNewWorkoutAdding event,
Emitter<WorkoutListState> emit,
) async {
try {
final name = event.name.withDefault('Workout');
final workout = Workout(name: name);
final workouts = List.of(state.plan!.workouts)..add(workout);
final plan = state.plan!.copyWith(workouts: workouts);
await _workoutRepository.savePlan(plan);
emit(
state.copyWith(
status: WorkoutListStatus.added,
plan: () => plan,
newWorkoutId: workout.id,
),
);
} catch (_) {
state.copyWith(status: WorkoutListStatus.failure);
}
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/workout_details.dart
|
export 'bloc/workout_details_bloc.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/view.dart
|
export 'widgets/widgets.dart';
export 'workout_details_page.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/workout_details_page.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:go_router/go_router.dart';
import 'package:user_repository/user_repository.dart';
import 'package:workout_repository/workout_repository.dart';
class WorkoutDetailsPage extends StatelessWidget {
const WorkoutDetailsPage({
required this.workoutId,
super.key,
});
static String name = 'workout-details';
static String path = '$name/:workoutId';
final String workoutId;
@override
Widget build(BuildContext context) {
return BlocProvider<WorkoutDetailsBloc>(
create: (context) {
final repository = context.read<WorkoutRepository>();
final userRepository = context.read<UserRepository>();
return WorkoutDetailsBloc(
workoutRepository: repository,
)..add(
WorkoutDetailsWorkoutSubscriptionRequested(
id: workoutId,
planId: userRepository.get().currentPlanId!,
),
);
},
child: const WorkoutDetailsView(),
);
}
}
class WorkoutDetailsView extends StatelessWidget {
const WorkoutDetailsView({super.key});
@override
Widget build(BuildContext context) {
return BlocConsumer<WorkoutDetailsBloc, WorkoutDetailsState>(
listenWhen: (previous, current) => previous.status != current.status,
listener: (context, state) {
if (state.status == WorkoutDetailsStatus.delete) {
context.pop();
}
},
buildWhen: (previous, current) => previous.status != current.status,
builder: (context, state) {
switch (state.status) {
case WorkoutDetailsStatus.init:
case WorkoutDetailsStatus.loading:
return const AppScaffold(body: AppLoading());
case WorkoutDetailsStatus.failure:
return const AppScaffold(body: AppError());
case WorkoutDetailsStatus.loaded:
case WorkoutDetailsStatus.empty:
case WorkoutDetailsStatus.updating:
case WorkoutDetailsStatus.updated:
case WorkoutDetailsStatus.delete:
final workout = state.workout!;
return AppScaffold(
title: workout.name,
// actions: const [FavoriteButton()],
body: ListView(
padding:
const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: const [
StartWorkoutButton(),
AddWorkoutExercise(),
WorkoutExercisesList(),
RenameWorkout(),
DeleteWorkout(),
],
),
);
}
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/delete_workout.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class DeleteWorkout extends StatelessWidget {
const DeleteWorkout({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
builder: (context, state) {
return DeleteButton(
text: context.locale.deleteWorkout,
dialogText: context.locale.deleteText(state.workout!.name),
onConfirm: () => context
.read<WorkoutDetailsBloc>()
.add(const WorkoutDetailsDelete()),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/favorite_button.dart
|
// import 'package:flutter/material.dart';
// import 'package:flutter_bloc/flutter_bloc.dart';
// import 'package:future_of_workout/src/styles/styles.dart';
// import 'package:future_of_workout/src/widgets/widgets.dart';
// import 'package:future_of_workout/src/workout/workout/workout.dart';
// class FavoriteButton extends StatelessWidget {
// const FavoriteButton({super.key});
// @override
// Widget build(BuildContext context) {
// return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
// buildWhen: (previous, current) =>
// previous.workout?.isFavorite != current.workout?.isFavorite,
// builder: (context, state) {
// final isFavorite = state.workout!.isFavorite;
// final iconData = isFavorite ? AppIcons.heartFilled : AppIcons.heart;
// final color = isFavorite ? AppColors.yellow : null;
// return IconButton(
// onPressed: () => context
// .read<WorkoutDetailsBloc>()
// .add(const WorkoutDetailsFavoritToggled()),
// icon: AppIcon(
// iconData: iconData,
// color: color,
// height: 48,
// widht: 48,
// ),
// );
// },
// );
// }
// }
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/widgets.dart
|
export 'add_workout_exercise.dart';
export 'delete_workout.dart';
export 'favorite_button.dart';
export 'rename_workout.dart';
export 'rename_workout_dialog.dart';
export 'start_workout_button.dart';
export 'workout_exercise_item.dart';
export 'workout_exercises_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/start_workout_button.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/current_workout/current_workout.dart';
import 'package:future_of_workout/src/home/home.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:go_router/go_router.dart';
class StartWorkoutButton extends StatelessWidget {
const StartWorkoutButton({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
buildWhen: (previous, current) =>
previous.workout?.workoutExercises !=
current.workout?.workoutExercises,
builder: (context, state) {
return Visibility(
visible: state.workout?.workoutExercises.isNotEmpty ?? false,
child: Padding(
padding: const EdgeInsets.only(bottom: 8),
child: BarButton(
text: context.locale.startWorkoutButtonText,
icon: const AppIcon(iconData: AppIcons.play),
onTap: () {
context
.read<CurrentWorkoutBloc>()
.add(CurrentWorkoutStartWorkout(id: state.workout!.id));
context.goNamed(
HomePage.name,
params: {'homePageTab': CurrentWorkoutPage.name},
);
},
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/add_workout_exercise.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:go_router/go_router.dart';
class AddWorkoutExercise extends StatelessWidget {
const AddWorkoutExercise({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
builder: (context, state) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AddButton(
text: context.locale.addExercise,
onTap: () {
context.pushNamed(
ExerciseListPage.name,
extra: ExerciseListExtra(
selectionType: SelectionType.multiple,
onConfirm: (selected) async {
context
.read<WorkoutDetailsBloc>()
.add(WorkoutDetailsAddExercises(exercises: selected));
},
),
);
},
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/workout_exercises_list.dart
|
import 'dart:ui';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:future_of_workout/src/workout/workouts/workouts.dart';
import 'package:go_router/go_router.dart';
class WorkoutExercisesList extends StatelessWidget {
const WorkoutExercisesList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
buildWhen: (previous, current) =>
previous.workout?.workoutExercises !=
current.workout?.workoutExercises,
builder: (context, state) {
final list = state.workout!.workoutExercises;
return ReorderableListView.builder(
physics: const NeverScrollableScrollPhysics(),
onReorder: (oldIndex, newIndex) {
context.read<WorkoutDetailsBloc>().add(
WorkoutDetailsReorder(
oldIndex: oldIndex,
newIndex: newIndex,
),
);
},
proxyDecorator: _proxyDecorator,
shrinkWrap: true,
itemCount: list.length,
itemBuilder: (context, index) {
final item = list[index];
return WorkoutExerciseItem(
key: Key('workout_exercise_item_${item.id}'),
workoutExercise: item,
onTap: () => context.goNamed(
WorkoutExerciseDetailsPage.name,
params: {
'homePageTab': WorkoutsPage.name,
'workoutId': state.workout!.id,
'workoutExerciseId': item.id,
},
),
);
},
);
},
);
}
Widget _proxyDecorator(Widget child, int index, Animation<double> animation) {
return AnimatedBuilder(
animation: animation,
builder: (BuildContext context, Widget? child) {
final animValue = Curves.easeInOut.transform(animation.value);
final elevation = lerpDouble(0, 6, animValue)!;
return Material(
elevation: elevation,
color: Colors.transparent,
shadowColor: Colors.transparent,
child: child,
);
},
child: child,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/rename_workout.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class RenameWorkout extends StatelessWidget {
const RenameWorkout({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutDetailsBloc, WorkoutDetailsState>(
buildWhen: (previous, current) =>
previous.workout?.name != current.workout?.name,
builder: (context, state) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: EditButton(
text: context.locale.rename,
onTap: () async {
final bloc = context.read<WorkoutDetailsBloc>();
await showDialog<void>(
context: context,
builder: (builderContext) => RenameWorkoutDialog(
name: state.workout!.name,
onConfirm: (value) =>
bloc.add(WorkoutDetailsRenameWorkout(name: value)),
),
);
},
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/rename_workout_dialog.dart
|
import 'package:future_of_workout/src/common.dart';
class RenameWorkoutDialog extends StatelessWidget {
const RenameWorkoutDialog({
required this.onConfirm,
required this.name,
super.key,
});
final ValueChanged<String> onConfirm;
final String name;
@override
Widget build(BuildContext context) {
final controller = TextEditingController(text: name);
return CustomDialog(
title: context.locale.changeName,
content: TextField(
controller: controller,
style: AppTextStyle.bold28,
decoration: InputDecoration(
hintText: context.locale.name,
),
),
onConfirm: () {
final name = controller.text;
onConfirm(name);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/view/widgets/workout_exercise_item.dart
|
import 'package:flutter_svg/flutter_svg.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:workout_api/workout_api.dart';
class WorkoutExerciseItem extends StatelessWidget {
const WorkoutExerciseItem({
super.key,
required this.workoutExercise,
this.onTap,
});
final WorkoutExercise workoutExercise;
final VoidCallback? onTap;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: CustomCard(
onTap: onTap,
child: Row(
children: [
Row(
children: [
SizedBox(
width: 80,
child: Padding(
padding: const EdgeInsets.all(8),
child: SvgPicture.asset(
workoutExercise.exercise.imagePath,
height: 64,
),
),
),
Column(
mainAxisAlignment: MainAxisAlignment.center,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
workoutExercise.exercise.name,
style: AppTextStyle.bold20,
),
Text(
context.locale
.seriesCount(workoutExercise.exerciseSeries.length),
style: AppTextStyle.medium16,
),
],
),
],
),
const Spacer(),
const Padding(
padding: EdgeInsets.only(right: 16),
child: AppIcon(iconData: AppIcons.right),
),
],
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/bloc/workout_details_bloc.dart
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:collection/collection.dart';
import 'package:equatable/equatable.dart';
import 'package:future_of_workout/src/shared/extensions.dart';
import 'package:workout_repository/workout_repository.dart';
part 'workout_details_event.dart';
part 'workout_details_state.dart';
class WorkoutDetailsBloc
extends Bloc<WorkoutDetailsEvent, WorkoutDetailsState> {
WorkoutDetailsBloc({
required WorkoutRepository workoutRepository,
}) : _workoutRepository = workoutRepository,
super(const WorkoutDetailsState()) {
on<WorkoutDetailsWorkoutSubscriptionRequested>(
_onWorkoutSubscriptionRequested,
);
on<WorkoutDetailsRenameWorkout>(_onRenameWorkout);
on<WorkoutDetailsDelete>(_onDelete);
on<WorkoutDetailsAddExercises>(_onAddExercises);
on<WorkoutDetailsReorder>(_onReorder);
}
final WorkoutRepository _workoutRepository;
Future<void> _onWorkoutSubscriptionRequested(
WorkoutDetailsWorkoutSubscriptionRequested event,
Emitter<WorkoutDetailsState> emit,
) async {
emit(state.copyWith(status: WorkoutDetailsStatus.loading));
await emit.forEach<Plan?>(
_workoutRepository.getPlanStream(id: event.planId),
onData: (plan) {
final workout = plan!.workouts
.firstWhereOrNull((element) => element.id == event.id);
return state.copyWith(
status: WorkoutDetailsStatus.loaded,
plan: plan,
workout: workout,
);
},
onError: (_, __) => state.copyWith(status: WorkoutDetailsStatus.failure),
);
}
Future<void> _onRenameWorkout(
WorkoutDetailsRenameWorkout event,
Emitter<WorkoutDetailsState> emit,
) async {
final name = event.name.withDefault('Workout');
await _updateWorkout(
workout: state.workout!.copyWith(name: name),
emit: emit,
);
}
Future<void> _onDelete(
WorkoutDetailsDelete event,
Emitter<WorkoutDetailsState> emit,
) async {
try {
final plan = state.plan!;
final workouts = List.of(plan.workouts)..remove(state.workout);
await _workoutRepository.savePlan(plan.copyWith(workouts: workouts));
emit(state.copyWith(status: WorkoutDetailsStatus.delete));
} catch (e) {
emit(state.copyWith(status: WorkoutDetailsStatus.failure));
}
}
Future<void> _onAddExercises(
WorkoutDetailsAddExercises event,
Emitter<WorkoutDetailsState> emit,
) async {
final workoutExercises = List.of(state.workout!.workoutExercises);
for (final exercise in event.exercises) {
final item = WorkoutExercise(
index: workoutExercises.length,
exercise: exercise,
);
workoutExercises.add(item);
}
final workout = state.workout!.copyWith(workoutExercises: workoutExercises);
await _updateWorkout(workout: workout, emit: emit);
}
Future<void> _updateWorkout({
required Workout workout,
required Emitter<WorkoutDetailsState> emit,
}) async {
try {
emit(state.copyWith(status: WorkoutDetailsStatus.updating));
final plan = state.plan!;
final workouts = List.of(plan.workouts);
final index = workouts.indexWhere((element) => element.id == workout.id);
workouts[index] = workout;
await _workoutRepository.savePlan(plan.copyWith(workouts: workouts));
emit(
state.copyWith(
status: WorkoutDetailsStatus.updated,
workout: workout,
),
);
} catch (e) {
emit(state.copyWith(status: WorkoutDetailsStatus.failure));
}
}
Future<void> _onReorder(
WorkoutDetailsReorder event,
Emitter<WorkoutDetailsState> emit,
) async {
final list = List.of(state.workout!.workoutExercises);
final exercise = list.removeAt(event.oldIndex);
final index =
event.newIndex > event.oldIndex ? event.newIndex - 1 : event.newIndex;
list.insert(index, exercise);
final workout = state.workout!.copyWith(workoutExercises: list);
await _updateWorkout(workout: workout, emit: emit);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/bloc/workout_details_state.dart
|
part of 'workout_details_bloc.dart';
enum WorkoutDetailsStatus {
init,
loading,
loaded,
updating,
updated,
empty,
delete,
failure,
}
class WorkoutDetailsState extends Equatable {
const WorkoutDetailsState({
this.workout,
this.plan,
this.status = WorkoutDetailsStatus.init,
});
final WorkoutDetailsStatus status;
final Workout? workout;
final Plan? plan;
WorkoutDetailsState copyWith({
WorkoutDetailsStatus? status,
Workout? workout,
Plan? plan,
}) {
return WorkoutDetailsState(
status: status ?? this.status,
workout: workout ?? this.workout,
plan: plan ?? this.plan,
);
}
@override
List<Object?> get props => [
status,
workout,
plan,
];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_details/bloc/workout_details_event.dart
|
part of 'workout_details_bloc.dart';
abstract class WorkoutDetailsEvent extends Equatable {
const WorkoutDetailsEvent();
@override
List<Object> get props => [];
}
class WorkoutDetailsWorkoutSubscriptionRequested extends WorkoutDetailsEvent {
const WorkoutDetailsWorkoutSubscriptionRequested({
required this.id,
required this.planId,
});
final String planId;
final String id;
@override
List<Object> get props => [id, planId];
}
class WorkoutDetailsRenameWorkout extends WorkoutDetailsEvent {
const WorkoutDetailsRenameWorkout({required this.name});
final String name;
@override
List<Object> get props => [name];
}
class WorkoutDetailsFavoritToggled extends WorkoutDetailsEvent {
const WorkoutDetailsFavoritToggled();
}
class WorkoutDetailsDelete extends WorkoutDetailsEvent {
const WorkoutDetailsDelete();
}
class WorkoutDetailsAddExercises extends WorkoutDetailsEvent {
const WorkoutDetailsAddExercises({required this.exercises});
final List<Exercise> exercises;
@override
List<Object> get props => [exercises];
}
class WorkoutDetailsReorder extends WorkoutDetailsEvent {
const WorkoutDetailsReorder({required this.oldIndex, required this.newIndex});
final int oldIndex;
final int newIndex;
@override
List<Object> get props => [oldIndex, newIndex];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/workout_exercise_details.dart
|
export 'bloc/workout_exercise_details_bloc.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/view.dart
|
export 'widgets/widgets.dart';
export 'workout_exercise_details_page.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/workout_exercise_details_page.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:go_router/go_router.dart';
import 'package:user_repository/user_repository.dart';
import 'package:workout_repository/workout_repository.dart';
class WorkoutExerciseDetailsPage extends StatelessWidget {
const WorkoutExerciseDetailsPage({
required this.workoutId,
required this.workoutExerciseId,
super.key,
});
static String name = 'workout-exercise-details';
static String path = '$name/:workoutExerciseId';
final String workoutId;
final String workoutExerciseId;
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) {
final planId = context.read<UserRepository>().get().currentPlanId!;
return WorkoutExerciseDetailsBloc(
workoutRepository: context.read<WorkoutRepository>(),
)..add(
WorkoutExerciseDetailsLoading(
workoutId: workoutId,
workoutExerciseId: workoutExerciseId,
planId: planId,
),
);
},
child: const WorkoutExerciseDetailsView(),
);
}
}
class WorkoutExerciseDetailsView extends StatelessWidget {
const WorkoutExerciseDetailsView({super.key});
@override
Widget build(BuildContext context) {
return WillPopScope(
onWillPop: () async {
context
.read<WorkoutExerciseDetailsBloc>()
.add(const WorkoutExerciseDetailsPop());
return true;
},
child:
BlocConsumer<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
listenWhen: (previous, current) => previous.status != current.status,
listener: (context, state) {
if (state.status == WorkoutExerciseDetailsStatus.delete) {
context.pop();
}
},
buildWhen: (previous, current) =>
previous.status != current.status ||
previous.workoutExercise?.exercise !=
current.workoutExercise?.exercise,
builder: (context, state) {
switch (state.status) {
case WorkoutExerciseDetailsStatus.initial:
case WorkoutExerciseDetailsStatus.loading:
return const AppScaffold(body: AppLoading());
case WorkoutExerciseDetailsStatus.failure:
return const AppScaffold(body: AppError());
case WorkoutExerciseDetailsStatus.loaded:
case WorkoutExerciseDetailsStatus.updating:
case WorkoutExerciseDetailsStatus.updated:
case WorkoutExerciseDetailsStatus.delete:
final workoutExercise = state.workoutExercise!;
return AppScaffold(
title: workoutExercise.exercise.name,
body: ListView(
padding:
const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: const [
AddSeries(),
RemoveSeries(),
SeriesList(),
DisplayMode(),
AboutExercise(),
ReplaceExercise(),
DeleteExercise(),
],
),
);
}
},
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/exercise_series_item.dart
|
import 'package:future_of_workout/src/app/bloc/app_bloc.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:workout_api/workout_api.dart';
class ExerciseSeriesItem extends StatelessWidget {
const ExerciseSeriesItem({
super.key,
required this.series,
required this.value,
this.isMulti = false,
});
final ExerciseSeries series;
final int value;
final bool isMulti;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: CustomCard(
onTap: () => onTap(context),
child: Column(
children: [
_SeriesData(value: value, series: series),
_RestData(series: series),
],
),
),
);
}
Future<void> onTap(BuildContext context) async {
final bloc = context.read<WorkoutExerciseDetailsBloc>();
final unit = context.read<AppBloc>().state.user!.weightUnit;
await showDialog<String>(
context: context,
builder: (context) {
return SeriesEditDialog(
title: isMulti
? context.locale.changeAllSeries
: context.locale.changeSeries(value),
reps: series.reps.toString(),
weight: UnitConverter.dispalyedWeight(
unit: unit,
value: series.weight,
).toString(),
weightSuffix: unit.sufix,
rest: series.rest.toString(),
onConfirm: (int reps, double weight, int rest) {
final value = UnitConverter.dataWeight(unit: unit, value: weight);
final newSeries = series.copyWith(
reps: reps,
weight: value,
rest: rest,
);
final event = isMulti
? WorkoutExerciseDetailsAllSeriesChanged(series: newSeries)
: WorkoutExerciseDetailsExerciseSeriesChanged(
index: series.index,
series: newSeries,
);
bloc.add(event);
},
);
},
);
}
}
class _SeriesData extends StatelessWidget {
const _SeriesData({
required this.value,
required this.series,
});
final int value;
final ExerciseSeries series;
@override
Widget build(BuildContext context) {
final unit = context.read<AppBloc>().state.user!.weightUnit;
return CustomCard(
padding: const EdgeInsets.all(8),
child: Row(
children: [
_SeriesNumber(value: value),
Expanded(
child: Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
BoldText(
boldText: UnitConverter.dispalyedWeight(
unit: unit,
value: series.weight,
).toString(),
mediumText: unit.sufix,
boldTextStyle: AppTextStyle.bold24,
),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 8),
child: Text(
'/',
style:
AppTextStyle.bold28.copyWith(color: AppColors.yellow),
),
),
BoldText(
boldText: series.reps.toString(),
mediumText: context.locale.reps,
boldTextStyle: AppTextStyle.bold24,
),
],
),
),
],
),
);
}
}
class _SeriesNumber extends StatelessWidget {
const _SeriesNumber({required this.value});
final int value;
@override
Widget build(BuildContext context) {
return Container(
height: 44,
width: 44,
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(64),
color: AppColors.yellow,
),
child: Center(
child: Text(
'$value',
style: AppTextStyle.bold28,
),
),
);
}
}
class _RestData extends StatelessWidget {
const _RestData({required this.series});
final ExerciseSeries series;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
const Padding(
padding: EdgeInsets.symmetric(horizontal: 8),
child: AppIcon(iconData: AppIcons.stopwatch),
),
BoldText(
boldText: series.rest.toString(),
mediumText: 's',
boldTextStyle: AppTextStyle.bold24,
),
],
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/display_mode.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout_exercise_details/workout_exercise_details.dart';
class DisplayMode extends StatelessWidget {
const DisplayMode({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
buildWhen: (previous, current) =>
previous.isAdvanced != current.isAdvanced,
builder: (context, state) {
final isAdvanced = state.isAdvanced;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: BarButton(
text: isAdvanced
? context.locale.simpleMode
: context.locale.advancedMode,
icon: isAdvanced
? const AppIcon(iconData: AppIcons.listLess)
: const AppIcon(iconData: AppIcons.listMore),
onTap: () {
context
.read<WorkoutExerciseDetailsBloc>()
.add(const WorkoutExerciseDetailsChangeDisplayMode());
},
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/delete_exercise.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout_exercise_details/workout_exercise_details.dart';
class DeleteExercise extends StatelessWidget {
const DeleteExercise({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
buildWhen: (previous, current) =>
previous.workoutExercise?.exercise !=
current.workoutExercise?.exercise,
builder: (context, state) {
final exercise = state.workoutExercise!.exercise;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: DeleteButton(
text: context.locale.deleteExercise,
dialogText: context.locale.deleteText(exercise.name),
onConfirm: () => context
.read<WorkoutExerciseDetailsBloc>()
.add(const WorkoutExerciseDetailsDeleteWorkoutExercise()),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/series_list.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class SeriesList extends StatelessWidget {
const SeriesList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
buildWhen: (previous, current) =>
previous.workoutExercise?.exerciseSeries !=
current.workoutExercise?.exerciseSeries ||
previous.isAdvanced != current.isAdvanced,
builder: (context, state) {
final list = state.workoutExercise!.exerciseSeries;
if (list.isEmpty) {
return Container();
}
// TODO(Animation): Animated list
if (!state.isAdvanced) {
return ExerciseSeriesItem(
series: list.first,
value: list.length,
isMulti: true,
);
}
return Column(
children: list.map<Widget>((series) {
return ExerciseSeriesItem(
series: series,
value: series.index,
);
}).toList(),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/series_edit_dialog.dart
|
import 'package:flutter/services.dart';
import 'package:future_of_workout/src/common.dart';
class SeriesEditDialog extends StatelessWidget {
const SeriesEditDialog({
required this.weight,
required this.reps,
required this.rest,
required this.onConfirm,
required this.title,
this.weightSuffix = 'kg',
super.key,
});
final String weight;
final String reps;
final String rest;
final String title;
final String weightSuffix;
final void Function(int reps, double weight, int rest) onConfirm;
@override
Widget build(BuildContext context) {
final weightController = TextEditingController(text: weight);
final repsController = TextEditingController(text: reps);
final restController = TextEditingController(text: rest);
return CustomDialog(
title: title,
content: Column(
mainAxisSize: MainAxisSize.min,
children: [
_WeightRow(controller: weightController, suffix: weightSuffix),
_RepsRow(controller: repsController),
_RestRow(controller: restController)
],
),
onConfirm: () {
final weight = double.tryParse(weightController.text) ?? 0;
final reps = int.tryParse(repsController.text) ?? 0;
final rest = int.tryParse(restController.text) ?? 0;
onConfirm(reps, weight, rest);
},
);
}
}
class _WeightRow extends StatelessWidget {
const _WeightRow({required this.controller, required this.suffix});
final TextEditingController controller;
final String suffix;
@override
Widget build(BuildContext context) {
return Row(
children: [
const Padding(
padding: EdgeInsets.only(right: 16),
child: AppIcon(iconData: AppIcons.weight),
),
Flexible(
child: TextField(
controller: controller,
keyboardType: TextInputType.number,
inputFormatters: [
FilteringTextInputFormatter.allow(
RegExp(r'^\d*\.?\d{0,2}'),
),
NumericalRangeFormatter(min: 0, max: 999)
],
textAlign: TextAlign.center,
style: AppTextStyle.bold28,
decoration: InputDecoration(
hintText: context.locale.weight,
suffixText: suffix,
counterText: '',
),
),
),
],
);
}
}
class _RepsRow extends StatelessWidget {
const _RepsRow({required this.controller});
final TextEditingController controller;
@override
Widget build(BuildContext context) {
return Row(
children: [
const Padding(
padding: EdgeInsets.only(right: 16),
child: AppIcon(iconData: AppIcons.repeat),
),
Flexible(
child: TextField(
controller: controller,
keyboardType: TextInputType.number,
inputFormatters: [
FilteringTextInputFormatter.digitsOnly,
NumericalRangeFormatter(min: 0, max: 999)
],
textAlign: TextAlign.center,
style: AppTextStyle.bold28,
decoration: InputDecoration(
hintText: context.locale.reps,
suffixText: context.locale.reps,
counterText: '',
),
),
),
],
);
}
}
class _RestRow extends StatelessWidget {
const _RestRow({required this.controller});
final TextEditingController controller;
@override
Widget build(BuildContext context) {
return Row(
children: [
const Padding(
padding: EdgeInsets.only(right: 16),
child: AppIcon(iconData: AppIcons.stopwatch),
),
Flexible(
child: TextField(
controller: controller,
keyboardType: TextInputType.number,
inputFormatters: [
FilteringTextInputFormatter.digitsOnly,
NumericalRangeFormatter(min: 0, max: 999)
],
textAlign: TextAlign.center,
style: AppTextStyle.bold28,
decoration: InputDecoration(
hintText: context.locale.restTime,
suffixText: 's',
counterText: '',
),
),
),
],
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/widgets.dart
|
export 'about_exercise.dart';
export 'add_series.dart';
export 'delete_exercise.dart';
export 'display_mode.dart';
export 'exercise_series_item.dart';
export 'remove_series.dart';
export 'replace_exercise.dart';
export 'series_edit_dialog.dart';
export 'series_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/remove_series.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class RemoveSeries extends StatelessWidget {
const RemoveSeries({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
buildWhen: (previous, current) =>
previous.workoutExercise?.exerciseSeries !=
current.workoutExercise?.exerciseSeries,
builder: (context, state) {
return Visibility(
visible: state.workoutExercise?.exerciseSeries.isNotEmpty ?? false,
child: Padding(
padding: const EdgeInsets.only(bottom: 8),
child: RemoveButton(
text: context.locale.deleteSeries,
onConfirm: () => context
.read<WorkoutExerciseDetailsBloc>()
.add(const WorkoutExerciseDetailsRemovedSeries()),
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/add_series.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class AddSeries extends StatelessWidget {
const AddSeries({super.key});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AddButton(
text: context.locale.addSeries,
onTap: () => context
.read<WorkoutExerciseDetailsBloc>()
.add(const WorkoutExerciseDetailsAddingSeries()),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/replace_exercise.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
import 'package:go_router/go_router.dart';
class ReplaceExercise extends StatelessWidget {
const ReplaceExercise({super.key});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: ReplaceButton(
text: context.locale.replaceExercise,
onTap: () {
context.pushNamed(
ExerciseListPage.name,
extra: ExerciseListExtra(
onConfirm: (selected) async {
context.read<WorkoutExerciseDetailsBloc>().add(
WorkoutExerciseDetailsReplace(exercise: selected.first),
);
},
),
);
},
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/view/widgets/about_exercise.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
import 'package:future_of_workout/src/workout/workout/workout.dart';
class AboutExercise extends StatelessWidget {
const AboutExercise({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<WorkoutExerciseDetailsBloc, WorkoutExerciseDetailsState>(
buildWhen: (previous, current) =>
previous.workoutExercise?.exercise !=
current.workoutExercise?.exercise,
builder: (context, state) {
final id = state.workoutExercise!.exercise.id;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AboutExerciseButton(exerciseId: id),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/bloc/workout_exercise_details_bloc.dart
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:workout_repository/workout_repository.dart';
part 'workout_exercise_details_event.dart';
part 'workout_exercise_details_state.dart';
class WorkoutExerciseDetailsBloc
extends Bloc<WorkoutExerciseDetailsEvent, WorkoutExerciseDetailsState> {
WorkoutExerciseDetailsBloc({required WorkoutRepository workoutRepository})
: _workoutRepository = workoutRepository,
super(const WorkoutExerciseDetailsState()) {
on<WorkoutExerciseDetailsLoading>(_onLoading);
on<WorkoutExerciseDetailsExerciseSeriesChanged>(_onExerciseSeriesChanged);
on<WorkoutExerciseDetailsAddingSeries>(_onAddingSeries);
on<WorkoutExerciseDetailsRemovedSeries>(_onRemovedSeries);
on<WorkoutExerciseDetailsDeleteWorkoutExercise>(_onDeleteWorkoutExercise);
on<WorkoutExerciseDetailsChangeDisplayMode>(_onChangeDisplayMode);
on<WorkoutExerciseDetailsAllSeriesChanged>(_onAllSeriesChanged);
on<WorkoutExerciseDetailsReplace>(_onReplace);
on<WorkoutExerciseDetailsPop>(_onPop);
}
final WorkoutRepository _workoutRepository;
Future<void> _onLoading(
WorkoutExerciseDetailsLoading event,
Emitter<WorkoutExerciseDetailsState> emit,
) async {
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.loading));
await emit.forEach<Plan?>(
_workoutRepository.getPlanStream(id: event.planId),
onData: (plan) {
final workout = plan!.workouts
.firstWhere((element) => element.id == event.workoutId);
final workoutExercise = workout.workoutExercises
.firstWhere((element) => element.id == event.workoutExerciseId);
return state.copyWith(
status: WorkoutExerciseDetailsStatus.loaded,
plan: plan,
workout: workout,
workoutExercise: workoutExercise,
isAdvanced: _getAdvanced(series: workoutExercise.exerciseSeries),
);
},
onError: (_, __) =>
state.copyWith(status: WorkoutExerciseDetailsStatus.failure),
);
}
bool _getAdvanced({required List<ExerciseSeries> series}) {
var isAdvanced = false;
if (series.isNotEmpty) {
final first = series.first;
isAdvanced = series.any(
(element) =>
element.reps != first.reps ||
element.weight != first.weight ||
element.rest != first.rest,
);
}
return isAdvanced;
}
void _onExerciseSeriesChanged(
WorkoutExerciseDetailsExerciseSeriesChanged event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final exerciseSeries = List.of(state.workoutExercise!.exerciseSeries);
exerciseSeries[event.index - 1] = event.series;
final newWorkoutExercise =
state.workoutExercise!.copyWith(exerciseSeries: exerciseSeries);
emit(state.copyWith(workoutExercise: newWorkoutExercise));
}
void _onAddingSeries(
WorkoutExerciseDetailsAddingSeries event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final exerciseSeries = List.of(state.workoutExercise!.exerciseSeries);
if (exerciseSeries.isEmpty) {
exerciseSeries.add(ExerciseSeries(index: 1));
} else {
final lastSeries = exerciseSeries.last;
exerciseSeries.add(lastSeries.copyWith(index: lastSeries.index + 1));
}
final newWorkoutExercise =
state.workoutExercise!.copyWith(exerciseSeries: exerciseSeries);
emit(state.copyWith(workoutExercise: newWorkoutExercise));
}
Future<void> _onDeleteWorkoutExercise(
WorkoutExerciseDetailsDeleteWorkoutExercise event,
Emitter<WorkoutExerciseDetailsState> emit,
) async {
try {
final workoutExercises = List.of(state.workout!.workoutExercises);
final index = workoutExercises
.indexWhere((element) => element.id == state.workoutExercise!.id);
workoutExercises.removeAt(index);
final workout =
state.workout!.copyWith(workoutExercises: workoutExercises);
final plan = state.plan!;
final workouts = List.of(plan.workouts);
final workoutIndex =
workouts.indexWhere((element) => element.id == workout.id);
workouts[workoutIndex] = workout;
await _workoutRepository.savePlan(plan.copyWith(workouts: workouts));
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.delete));
} catch (e) {
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.failure));
}
}
void _onChangeDisplayMode(
WorkoutExerciseDetailsChangeDisplayMode event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final isAdvanced = state.isAdvanced;
WorkoutExercise? newWorkoutExercise;
if (!isAdvanced) {
final list = <ExerciseSeries>[];
final first = state.workoutExercise!.exerciseSeries.first;
for (final series in state.workoutExercise!.exerciseSeries) {
list.add(
series.copyWith(
reps: first.reps,
weight: first.weight,
rest: first.rest,
),
);
}
newWorkoutExercise =
state.workoutExercise!.copyWith(exerciseSeries: list);
}
emit(
state.copyWith(
workoutExercise: newWorkoutExercise,
isAdvanced: !isAdvanced,
),
);
}
void _onAllSeriesChanged(
WorkoutExerciseDetailsAllSeriesChanged event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final list = <ExerciseSeries>[];
for (final series in state.workoutExercise!.exerciseSeries) {
list.add(
series.copyWith(
reps: event.series.reps,
weight: event.series.weight,
rest: event.series.rest,
),
);
}
final newWorkoutExercise =
state.workoutExercise!.copyWith(exerciseSeries: list);
emit(state.copyWith(workoutExercise: newWorkoutExercise));
}
void _onRemovedSeries(
WorkoutExerciseDetailsRemovedSeries event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final exerciseSeries = List.of(state.workoutExercise!.exerciseSeries);
if (exerciseSeries.isEmpty) return;
exerciseSeries.removeLast();
final newWorkoutExercise =
state.workoutExercise!.copyWith(exerciseSeries: exerciseSeries);
emit(state.copyWith(workoutExercise: newWorkoutExercise));
}
Future<void> _onPop(
WorkoutExerciseDetailsPop event,
Emitter<WorkoutExerciseDetailsState> emit,
) async {
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.updating));
try {
final workoutExercises = List.of(state.workout!.workoutExercises);
final index = workoutExercises
.indexWhere((element) => element.id == state.workoutExercise!.id);
workoutExercises[index] = state.workoutExercise!;
final workout =
state.workout!.copyWith(workoutExercises: workoutExercises);
final plan = state.plan!;
final workouts = List.of(plan.workouts);
final workoutIndex =
workouts.indexWhere((element) => element.id == workout.id);
workouts[workoutIndex] = workout;
await _workoutRepository.savePlan(plan.copyWith(workouts: workouts));
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.updated));
} catch (e) {
emit(state.copyWith(status: WorkoutExerciseDetailsStatus.failure));
}
}
void _onReplace(
WorkoutExerciseDetailsReplace event,
Emitter<WorkoutExerciseDetailsState> emit,
) {
final workoutExercise =
state.workoutExercise!.copyWith(exercise: event.exercise);
emit(state.copyWith(workoutExercise: workoutExercise));
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/bloc/workout_exercise_details_state.dart
|
part of 'workout_exercise_details_bloc.dart';
enum WorkoutExerciseDetailsStatus {
initial,
loading,
loaded,
updating,
updated,
delete,
failure,
}
class WorkoutExerciseDetailsState extends Equatable {
const WorkoutExerciseDetailsState({
this.status = WorkoutExerciseDetailsStatus.initial,
this.isAdvanced = false,
this.workoutExercise,
this.workout,
this.plan,
});
final WorkoutExerciseDetailsStatus status;
final WorkoutExercise? workoutExercise;
final bool isAdvanced;
final Workout? workout;
final Plan? plan;
@override
List<Object?> get props => [
status,
workoutExercise,
isAdvanced,
workout,
plan,
];
WorkoutExerciseDetailsState copyWith({
WorkoutExerciseDetailsStatus? status,
WorkoutExercise? workoutExercise,
bool? isAdvanced,
Workout? workout,
Plan? plan,
}) {
return WorkoutExerciseDetailsState(
status: status ?? this.status,
workoutExercise: workoutExercise ?? this.workoutExercise,
isAdvanced: isAdvanced ?? this.isAdvanced,
workout: workout ?? this.workout,
plan: plan ?? this.plan,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details
|
mirrored_repositories/future_of_workout/lib/src/workout/workout/workout_exercise_details/bloc/workout_exercise_details_event.dart
|
part of 'workout_exercise_details_bloc.dart';
abstract class WorkoutExerciseDetailsEvent extends Equatable {
const WorkoutExerciseDetailsEvent();
@override
List<Object> get props => [];
}
class WorkoutExerciseDetailsLoading extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsLoading({
required this.planId,
required this.workoutId,
required this.workoutExerciseId,
});
final String planId;
final String workoutId;
final String workoutExerciseId;
@override
List<Object> get props => [planId, workoutId, workoutExerciseId];
}
class WorkoutExerciseDetailsExerciseSeriesChanged
extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsExerciseSeriesChanged({
required this.index,
required this.series,
});
final int index;
final ExerciseSeries series;
@override
List<Object> get props => [index, series];
}
class WorkoutExerciseDetailsAllSeriesChanged
extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsAllSeriesChanged({
required this.series,
});
final ExerciseSeries series;
@override
List<Object> get props => [series];
}
class WorkoutExerciseDetailsAddingSeries extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsAddingSeries();
}
class WorkoutExerciseDetailsRemovedSeries extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsRemovedSeries();
}
class WorkoutExerciseDetailsPop extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsPop();
}
class WorkoutExerciseDetailsDeleteWorkoutExercise
extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsDeleteWorkoutExercise();
}
class WorkoutExerciseDetailsChangeDisplayMode
extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsChangeDisplayMode();
}
class WorkoutExerciseDetailsReplace extends WorkoutExerciseDetailsEvent {
const WorkoutExerciseDetailsReplace({required this.exercise});
final Exercise exercise;
@override
List<Object> get props => [exercise];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise.dart
|
export 'exercise_details/exercise_details.dart';
export 'exercise_list/exercise_list.dart';
export 'exercise_stats/exercise_stats.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/exercise_details.dart
|
export 'bloc/exercise_details_bloc.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/view.dart
|
export 'exercise_details_page.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/exercise_details_page.dart
|
import 'package:exercise_repository/exercise_repository.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/exercise/exercise_details/view/widgets/widgets.dart';
class ExerciseDetailsPage extends StatelessWidget {
const ExerciseDetailsPage({required this.exerciseId, super.key});
final String exerciseId;
static String name = '/exercise-details';
static String path = '$name/:exerciseId';
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) => ExerciseDetailsBloc(
exerciseRepository: context.read<ExerciseRepository>(),
)..add(ExerciseDetailsLoadingRequested(id: exerciseId)),
child: const ExerciseDetailsView(),
);
}
}
class ExerciseDetailsView extends StatelessWidget {
const ExerciseDetailsView({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseDetailsBloc, ExerciseDetailsState>(
buildWhen: (previous, current) => previous.status != current.status,
builder: (context, state) {
switch (state.status) {
case ExerciseDetailsStatus.initial:
case ExerciseDetailsStatus.loading:
return const AppScaffold(body: AppLoading());
case ExerciseDetailsStatus.failure:
return const AppScaffold(body: AppError());
case ExerciseDetailsStatus.success:
final exercise = state.exercise!;
return AppScaffold(
title: state.exercise!.name,
body: ListView(
padding:
const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: [
ExerciseImagesCard(
imagePath: exercise.imagePath,
imagePathSecondary: exercise.imagePathSecondary,
),
const InststuctionsList(),
const MusclesList(),
// TODO(Feature): Equipment
//const EquipmentList(),
// TODO(Feature): Note
],
),
);
}
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/equipment_list.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/exercise/exercise_details/view/widgets/widgets.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
class EquipmentList extends StatelessWidget {
const EquipmentList({
this.padding = const EdgeInsets.symmetric(vertical: 8),
super.key,
});
final EdgeInsets padding;
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseDetailsBloc, ExerciseDetailsState>(
builder: (context, state) {
final equipments = <String>[];
return Padding(
padding: padding,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
if (equipments.isNotEmpty)
..._buildSection(title: 'Equiments', equipments: equipments),
],
),
);
},
);
}
List<Widget> _buildSection({
required String title,
required List<String> equipments,
}) {
return [
Header(text: title),
for (var equipment in equipments) InstructionItem(text: equipment),
];
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/instructions_list.dart
|
import 'package:exercise_repository/exercise_repository.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/exercise/exercise_details/view/widgets/widgets.dart';
class InststuctionsList extends StatelessWidget {
const InststuctionsList({
this.padding = const EdgeInsets.symmetric(vertical: 8),
super.key,
});
final EdgeInsets padding;
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseDetailsBloc, ExerciseDetailsState>(
buildWhen: (previous, current) => previous.exercise != current.exercise,
builder: (context, state) {
final repository = context.read<ExerciseRepository>();
if (repository.instructions == null) {
final locale = Localizations.localeOf(context);
repository.initInstructions(languageCode: locale.languageCode);
}
final list = repository.getInstructions(id: state.exercise!.id);
return Visibility(
visible: list.isNotEmpty,
child: Padding(
padding: padding,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Header(text: context.locale.instructions),
...list.map((text) => InstructionItem(text: text)).toList(),
],
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/muscles_list.dart
|
import 'package:exercise_api/exercise_api.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/exercise/exercise_details/view/widgets/widgets.dart';
class MusclesList extends StatelessWidget {
const MusclesList({
this.padding = const EdgeInsets.symmetric(vertical: 8),
super.key,
});
final EdgeInsets padding;
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseDetailsBloc, ExerciseDetailsState>(
builder: (context, state) {
final muscles = state.exercise!.muscles;
final primary = muscles.keys
.where((element) => muscles[element] == MuscleInvolvement.primary)
.toList();
final secondary = muscles.keys
.where((element) => muscles[element] != MuscleInvolvement.primary)
.toList();
return Padding(
padding: padding,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
..._buildSection(
title: context.locale.primaryMuscle,
muscles: primary,
),
if (secondary.isNotEmpty)
..._buildSection(
title: context.locale.secondaryMuscle,
muscles: secondary,
),
],
),
);
},
);
}
List<Widget> _buildSection({
required String title,
required List<Muscle> muscles,
}) {
return [
Header(text: title),
for (var muscle in muscles) MuscleItem(muscle: muscle),
];
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/muscle_item.dart
|
import 'package:exercise_api/exercise_api.dart';
import 'package:future_of_workout/src/common.dart';
class MuscleItem extends StatelessWidget {
const MuscleItem({
required this.muscle,
super.key,
});
final Muscle muscle;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: CustomCard(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
child: Row(
children: [
Expanded(
child: Text(
context.locale.muscle(muscle.name),
style: AppTextStyle.medium16,
),
),
],
),
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/widgets.dart
|
export 'equipment_list.dart';
export 'exercise_images_card.dart';
export 'instruction_item.dart';
export 'instructions_list.dart';
export 'muscle_item.dart';
export 'muscles_list.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/exercise_images_card.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_svg/flutter_svg.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
class ExerciseImagesCard extends StatelessWidget {
const ExerciseImagesCard({
required this.imagePath,
required this.imagePathSecondary,
this.padding = const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
super.key,
});
final String imagePath;
final String imagePathSecondary;
final EdgeInsets padding;
@override
Widget build(BuildContext context) {
return CustomCard(
child: Padding(
padding: const EdgeInsets.all(8),
child: LayoutBuilder(
builder: (context, constraints) {
final size = constraints.maxWidth / 2;
return Row(
crossAxisAlignment: CrossAxisAlignment.end,
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
SvgPicture.asset(
imagePath,
width: size,
),
SvgPicture.asset(
imagePathSecondary,
width: size,
),
],
);
},
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/view/widgets/instruction_item.dart
|
import 'package:flutter/material.dart';
import 'package:future_of_workout/src/styles/app_text_style.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
class InstructionItem extends StatelessWidget {
const InstructionItem({
required this.text,
this.padding = const EdgeInsets.only(bottom: 8),
super.key,
});
final String text;
final EdgeInsets padding;
@override
Widget build(BuildContext context) {
return Padding(
padding: padding,
child: CustomCard(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
child: Row(
children: [
Expanded(
child: Text(
text,
style: AppTextStyle.medium16,
),
),
],
),
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/bloc/exercise_details_state.dart
|
part of 'exercise_details_bloc.dart';
enum ExerciseDetailsStatus {
initial,
loading,
success,
failure,
}
class ExerciseDetailsState extends Equatable {
const ExerciseDetailsState({
this.status = ExerciseDetailsStatus.initial,
this.exercise,
});
final ExerciseDetailsStatus status;
final Exercise? exercise;
@override
List<Object?> get props => [status, exercise];
ExerciseDetailsState copyWith({
ExerciseDetailsStatus? status,
Exercise? exercise,
}) {
return ExerciseDetailsState(
status: status ?? this.status,
exercise: exercise ?? this.exercise,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/bloc/exercise_details_event.dart
|
part of 'exercise_details_bloc.dart';
abstract class ExerciseDetailsEvent extends Equatable {
const ExerciseDetailsEvent();
@override
List<Object> get props => [];
}
class ExerciseDetailsLoadingRequested extends ExerciseDetailsEvent {
const ExerciseDetailsLoadingRequested({
required this.id,
});
final String id;
@override
List<Object> get props => [id];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_details/bloc/exercise_details_bloc.dart
|
import 'package:bloc/bloc.dart';
import 'package:equatable/equatable.dart';
import 'package:exercise_api/exercise_api.dart';
import 'package:exercise_repository/exercise_repository.dart';
part 'exercise_details_event.dart';
part 'exercise_details_state.dart';
class ExerciseDetailsBloc
extends Bloc<ExerciseDetailsEvent, ExerciseDetailsState> {
ExerciseDetailsBloc({required ExerciseRepository exerciseRepository})
: _exerciseRepository = exerciseRepository,
super(const ExerciseDetailsState()) {
on<ExerciseDetailsLoadingRequested>(_onLoadingRequested);
}
final ExerciseRepository _exerciseRepository;
void _onLoadingRequested(
ExerciseDetailsLoadingRequested event,
Emitter<ExerciseDetailsState> emit,
) {
emit(state.copyWith(status: ExerciseDetailsStatus.loading));
try {
final exercise = _exerciseRepository.get(id: event.id);
emit(
state.copyWith(
status: ExerciseDetailsStatus.success,
exercise: exercise,
),
);
} on ExerciseNotFoundException catch (_) {
emit(state.copyWith(status: ExerciseDetailsStatus.failure));
}
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/exercise_stats.dart
|
export 'bloc/exercise_stats_bloc.dart';
export 'models/models.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/exercise_stats_page.dart
|
import 'package:exercise_repository/exercise_repository.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:goal_repository/goal_repository.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
class ExerciseStatsPage extends StatelessWidget {
const ExerciseStatsPage({required this.exerciseId, super.key});
final String exerciseId;
static String name = '/exercise-stats';
static String path = '$name/:exerciseId';
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) => ExerciseStatsBloc(
exerciseRepository: context.read<ExerciseRepository>(),
workoutLogRepository: context.read<WorkoutLogRepository>(),
goalRepository: context.read<GoalRepository>(),
)
..add(ExerciseStatsLoadExercise(exerciseId: exerciseId))
..add(ExerciseStatsLoadWorkoutLogs(exerciseId: exerciseId))
..add(ExerciseStatsLoadGoal(exerciseId: exerciseId)),
child: const ExerciseStatsView(),
);
}
}
class ExerciseStatsView extends StatelessWidget {
const ExerciseStatsView({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.status != current.status,
builder: (context, state) {
switch (state.status) {
case ExerciseStatsStatus.initial:
case ExerciseStatsStatus.loading:
return const AppScaffold(body: AppLoading());
case ExerciseStatsStatus.failure:
return const AppScaffold(body: AppError());
case ExerciseStatsStatus.loaded:
final exercise = state.exercise;
return AppScaffold(
title: exercise?.name ?? context.locale.exercises,
body: ListView(
padding:
const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: const [
AboutExercise(),
AddGoal(),
GoalCard(),
DataList(),
],
),
);
}
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/view.dart
|
export 'exercise_stats_page.dart';
export 'widgets/widgets.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/goal_card.dart
|
import 'package:future_of_workout/src/app/bloc/app_bloc.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class GoalCard extends StatelessWidget {
const GoalCard({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.goal != current.goal,
builder: (context, state) {
final goal = state.goal;
if (goal == null) {
return Container();
}
final unit = context.read<AppBloc>().state.user!.weightUnit;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: CustomCard(
onTap: () async {
final bloc = context.read<ExerciseStatsBloc>();
await showDialog<void>(
context: context,
builder: (_) {
return GoalDialog(
title: context.locale.updateGoal,
confirmButtonText: context.locale.save,
value: UnitConverter.dispalyedWeight(
unit: unit,
value: goal.goal,
).toString(),
suffix: unit.sufix,
onConfirm: (value) {
if (value != 0) {
bloc.add(
ExerciseStatsGoalChange(
value: UnitConverter.dataWeight(
unit: unit,
value: value,
),
),
);
} else {
bloc.add(const ExerciseStatsGoalDelete());
}
},
onDelete: () => bloc.add(const ExerciseStatsGoalDelete()),
);
},
);
},
child: Padding(
padding: const EdgeInsets.only(left: 16, top: 8, bottom: 8),
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Text(
'${context.locale.goal}:',
style: AppTextStyle.semiBold20,
),
Row(
crossAxisAlignment: CrossAxisAlignment.baseline,
textBaseline: TextBaseline.ideographic,
children: [
Text(
UnitConverter.dispalyedWeight(
unit: unit,
value: goal.goal,
).toString(),
style: AppTextStyle.bold28,
),
Text(unit.sufix, style: AppTextStyle.medium20),
],
),
const Padding(
padding: EdgeInsets.all(8),
child: Icon(Icons.edit),
),
],
),
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/log_item.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:intl/intl.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
class LogItem extends StatelessWidget {
const LogItem({
required this.workoutExerciseLog,
required this.date,
super.key,
});
final WorkoutExerciseLog workoutExerciseLog;
final DateTime date;
@override
Widget build(BuildContext context) {
final formatter = DateFormat('EEEEE, dd MMMM', context.languageCode);
return WorkoutExerciseLogDetailsItem(
workoutExerciseLog: workoutExerciseLog,
header: Padding(
padding: const EdgeInsets.all(8),
child: Text(
formatter.format(date),
style: AppTextStyle.bold24,
),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/chart_type_bar.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class ChartTypeBar extends StatelessWidget {
const ChartTypeBar({super.key});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: ToggleBar(
onChange: (index) {
context.read<ExerciseStatsBloc>().add(
ExerciseStatsChartTypeChange(
chartType: ChartType.values[index],
),
);
},
tabs: ChartType.values
.map<Tab>(
(period) => Tab(text: context.locale.chartType(period.name)),
)
.toList(),
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/data_period.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
class DataPeriod extends StatelessWidget {
const DataPeriod({super.key});
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: PeriodBar(
onChange: (period) {
context
.read<ExerciseStatsBloc>()
.add(ExerciseStatsPeriodChange(period: period));
},
),
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/weight_chart.dart
|
import 'dart:math';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/app/bloc/app_bloc.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/shared/one_rep_max_calculator.dart';
import 'package:future_of_workout/src/shared/unit_converter.dart';
import 'package:future_of_workout/src/widgets/widgets.dart';
import 'package:user_repository/user_repository.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
class WeightChart extends StatelessWidget {
const WeightChart({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) =>
previous.data != current.data ||
previous.chartType != current.chartType,
builder: (context, state) {
final unit = context.read<AppBloc>().state.user!.weightUnit;
final data = _getData(
data: state.data,
chartType: state.chartType,
unit: unit,
);
final goal = state.chartType == ChartType.weight && state.goal != null
? UnitConverter.dispalyedWeight(unit: unit, value: state.goal!.goal)
: null;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: CustomCard(
child: ClipRRect(
child: Padding(
padding: const EdgeInsets.only(
right: 16,
left: 8,
top: 24,
bottom: 8,
),
child: DayliChart(
suffix: unit.sufix,
goal: goal,
isCurved: false,
period: state.period.days,
data: data,
),
),
),
),
);
},
);
}
List<DayliData> _getData({
required List<MapEntry<WorkoutExerciseLog, DateTime>> data,
required ChartType chartType,
required WeightUnit unit,
}) {
return data.map<DayliData>((entry) {
final finished =
entry.key.exerciseSeriesLogs.where((series) => series.isFinished);
final double value;
switch (chartType) {
case ChartType.weight:
value = finished.map((series) => series.weight).reduce(max);
break;
case ChartType.volume:
value = finished.fold(
0,
(previousValue, series) =>
previousValue + (series.weight * series.reps),
);
break;
case ChartType.oneRepMax:
value = finished
.map(
(series) => OneRepMaxCalculator.calculate(
reps: series.reps,
weight: series.weight,
intensity: series.intensity,
),
)
.reduce(max);
break;
}
return DayliData(
value: UnitConverter.dispalyedWeight(unit: unit, value: value),
date: entry.value,
);
}).toList();
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/data_list.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class DataList extends StatelessWidget {
const DataList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.data != current.data,
builder: (context, state) {
if (state.data.isEmpty) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 32),
child: AppEmptyList(
text: context.locale.exerciseStatsEmptyList,
),
);
}
return Column(
children: const [
DataPeriod(),
ChartTypeBar(),
WeightChart(),
LogsList(),
],
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/widgets.dart
|
export 'about_exercise.dart';
export 'add_goal.dart';
export 'chart_type_bar.dart';
export 'data_list.dart';
export 'data_period.dart';
export 'goal_card.dart';
export 'log_item.dart';
export 'logs_list.dart';
export 'weight_chart.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/add_goal.dart
|
import 'package:future_of_workout/src/app/bloc/app_bloc.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class AddGoal extends StatelessWidget {
const AddGoal({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.goal != current.goal,
builder: (context, state) {
return Visibility(
visible: state.goal == null,
child: Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AddButton(
text: context.locale.addGoal,
onTap: () async {
final unit = context.read<AppBloc>().state.user!.weightUnit;
final bloc = context.read<ExerciseStatsBloc>();
await showDialog<void>(
context: context,
builder: (_) {
return GoalDialog(
title: context.locale.addGoal,
suffix: unit.sufix,
onConfirm: (value) {
if (value != 0) {
bloc.add(
ExerciseStatsAddGoal(
value: UnitConverter.dataWeight(
unit: unit,
value: value,
),
),
);
}
},
);
},
);
},
),
),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/logs_list.dart
|
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class LogsList extends StatelessWidget {
const LogsList({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.data != current.data,
builder: (context, state) {
final list = state.data;
return ListView(
shrinkWrap: true,
physics: const BouncingScrollPhysics(),
children: [
Header(text: context.locale.logs(list.length)),
...list
.map<Widget>(
(entry) => LogItem(
workoutExerciseLog: entry.key,
date: entry.value,
),
)
.toList(),
],
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/view/widgets/about_exercise.dart
|
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/widgets/buttons/about_exercise_button.dart';
class AboutExercise extends StatelessWidget {
const AboutExercise({super.key});
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseStatsBloc, ExerciseStatsState>(
buildWhen: (previous, current) => previous.exercise != current.exercise,
builder: (context, state) {
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: AboutExerciseButton(exerciseId: state.exercise!.id),
);
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/models/chart_type.dart
|
enum ChartType {
weight,
volume,
oneRepMax,
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/models/models.dart
|
export 'chart_type.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/bloc/exercise_stats_bloc.dart
|
import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:collection/collection.dart';
import 'package:equatable/equatable.dart';
import 'package:exercise_repository/exercise_repository.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:future_of_workout/src/shared/period.dart';
import 'package:goal_repository/goal_repository.dart';
import 'package:workout_log_repository/workout_log_repository.dart';
part 'exercise_stats_event.dart';
part 'exercise_stats_state.dart';
class ExerciseStatsBloc extends Bloc<ExerciseStatsEvent, ExerciseStatsState> {
ExerciseStatsBloc({
required ExerciseRepository exerciseRepository,
required WorkoutLogRepository workoutLogRepository,
required GoalRepository goalRepository,
}) : _exerciseRepository = exerciseRepository,
_workoutLogRepository = workoutLogRepository,
_goalRepository = goalRepository,
super(const ExerciseStatsState()) {
on<ExerciseStatsLoadExercise>(_onLoadExercise);
on<ExerciseStatsLoadWorkoutLogs>(_onLoadWorkoutLogs);
on<ExerciseStatsLoadGoal>(_onLoadGoal);
on<ExerciseStatsPeriodChange>(_onPeriodChange);
on<ExerciseStatsChartTypeChange>(_onChartTypeChange);
on<ExerciseStatsGoalChange>(_onGoalChange);
on<ExerciseStatsGoalDelete>(_onGoalDelete);
on<ExerciseStatsAddGoal>(_onAddGoal);
}
final ExerciseRepository _exerciseRepository;
final WorkoutLogRepository _workoutLogRepository;
final GoalRepository _goalRepository;
Future<void> _onLoadExercise(
ExerciseStatsLoadExercise event,
Emitter<ExerciseStatsState> emit,
) async {
try {
emit(state.copyWith(status: ExerciseStatsStatus.loading));
final id = event.exerciseId;
final exercise = _exerciseRepository.get(id: id);
emit(
state.copyWith(
status: ExerciseStatsStatus.loaded,
exercise: exercise,
),
);
} catch (e) {
emit(state.copyWith(status: ExerciseStatsStatus.failure));
}
}
Future<void> _onLoadWorkoutLogs(
ExerciseStatsLoadWorkoutLogs event,
Emitter<ExerciseStatsState> emit,
) async {
final id = event.exerciseId;
await emit.forEach<List<WorkoutLog>>(
_workoutLogRepository.getWorkoutLogs(),
onData: (data) {
final list = <WorkoutExerciseLog, DateTime>{};
for (final workoutLog in data) {
for (final exerciseLog in workoutLog.workoutExerciseLogs) {
if (exerciseLog.exercise.id == id) {
if (exerciseLog.exerciseSeriesLogs
.any((series) => series.isFinished)) {
list.putIfAbsent(exerciseLog, () => workoutLog.startDate);
}
}
}
}
final sorted = list.entries.toList()
..sort(
(a, b) => b.value.compareTo(a.value),
);
return state.copyWith(
status: ExerciseStatsStatus.loaded,
workoutExerciseLogs: sorted,
);
},
onError: (_, __) => state.copyWith(status: ExerciseStatsStatus.failure),
);
}
Future<void> _onLoadGoal(
ExerciseStatsLoadGoal event,
Emitter<ExerciseStatsState> emit,
) async {
final id = event.exerciseId;
await emit.forEach<List<Goal>>(
_goalRepository.getGoals(),
onData: (data) {
final goal =
data.firstWhereOrNull((element) => element.exercise.id == id);
return state.copyWith(
status: ExerciseStatsStatus.loaded,
goal: () => goal,
);
},
onError: (_, __) => state.copyWith(status: ExerciseStatsStatus.failure),
);
}
void _onPeriodChange(
ExerciseStatsPeriodChange event,
Emitter<ExerciseStatsState> emit,
) {
emit(state.copyWith(period: event.period));
}
void _onChartTypeChange(
ExerciseStatsChartTypeChange event,
Emitter<ExerciseStatsState> emit,
) {
emit(state.copyWith(chartType: event.chartType));
}
Future<void> _onGoalDelete(
ExerciseStatsGoalDelete event,
Emitter<ExerciseStatsState> emit,
) async {
await _goalRepository.deleteGoal(state.goal!.id);
emit(state.copyWith(goal: () => null));
}
Future<void> _onGoalChange(
ExerciseStatsGoalChange event,
Emitter<ExerciseStatsState> emit,
) async {
final goal = state.goal!.copyWith(goal: event.value);
await _goalRepository.saveGoal(goal);
emit(state.copyWith(goal: () => goal));
}
Future<void> _onAddGoal(
ExerciseStatsAddGoal event,
Emitter<ExerciseStatsState> emit,
) async {
final goal = Goal(exercise: state.exercise!, goal: event.value);
await _goalRepository.saveGoal(goal);
emit(state.copyWith(goal: () => goal));
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/bloc/exercise_stats_state.dart
|
part of 'exercise_stats_bloc.dart';
enum ExerciseStatsStatus {
initial,
loading,
loaded,
failure,
}
class ExerciseStatsState extends Equatable {
const ExerciseStatsState({
this.status = ExerciseStatsStatus.initial,
this.workoutExerciseLogs = const [],
this.exercise,
this.period = Period.oneMounth,
this.chartType = ChartType.weight,
this.goal,
});
final ExerciseStatsStatus status;
final Exercise? exercise;
final List<MapEntry<WorkoutExerciseLog, DateTime>> workoutExerciseLogs;
final Goal? goal;
final Period period;
final ChartType chartType;
List<MapEntry<WorkoutExerciseLog, DateTime>> get data {
return workoutExerciseLogs.where((element) {
final difference = DateTime.now().difference(element.value).inDays;
return difference <= period.days;
}).toList();
}
@override
List<Object?> get props => [
status,
exercise,
workoutExerciseLogs,
goal,
period,
chartType,
];
ExerciseStatsState copyWith({
ExerciseStatsStatus? status,
Exercise? exercise,
List<MapEntry<WorkoutExerciseLog, DateTime>>? workoutExerciseLogs,
Goal? Function()? goal,
Period? period,
ChartType? chartType,
}) {
return ExerciseStatsState(
status: status ?? this.status,
exercise: exercise ?? this.exercise,
workoutExerciseLogs: workoutExerciseLogs ?? this.workoutExerciseLogs,
goal: goal != null ? goal() : this.goal,
period: period ?? this.period,
chartType: chartType ?? this.chartType,
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_stats/bloc/exercise_stats_event.dart
|
part of 'exercise_stats_bloc.dart';
abstract class ExerciseStatsEvent extends Equatable {
const ExerciseStatsEvent();
@override
List<Object> get props => [];
}
class ExerciseStatsLoadExercise extends ExerciseStatsEvent {
const ExerciseStatsLoadExercise({required this.exerciseId});
final String exerciseId;
@override
List<Object> get props => [exerciseId];
}
class ExerciseStatsLoadGoal extends ExerciseStatsEvent {
const ExerciseStatsLoadGoal({required this.exerciseId});
final String exerciseId;
@override
List<Object> get props => [exerciseId];
}
class ExerciseStatsLoadWorkoutLogs extends ExerciseStatsEvent {
const ExerciseStatsLoadWorkoutLogs({required this.exerciseId});
final String exerciseId;
@override
List<Object> get props => [exerciseId];
}
class ExerciseStatsGoalChange extends ExerciseStatsEvent {
const ExerciseStatsGoalChange({required this.value});
final double value;
@override
List<Object> get props => [value];
}
class ExerciseStatsAddGoal extends ExerciseStatsEvent {
const ExerciseStatsAddGoal({required this.value});
final double value;
@override
List<Object> get props => [value];
}
class ExerciseStatsGoalDelete extends ExerciseStatsEvent {
const ExerciseStatsGoalDelete();
}
class ExerciseStatsPeriodChange extends ExerciseStatsEvent {
const ExerciseStatsPeriodChange({required this.period});
final Period period;
@override
List<Object> get props => [period];
}
class ExerciseStatsChartTypeChange extends ExerciseStatsEvent {
const ExerciseStatsChartTypeChange({required this.chartType});
final ChartType chartType;
@override
List<Object> get props => [chartType];
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/exercise_list.dart
|
export 'bloc/exercise_list_bloc.dart';
export 'models/models.dart';
export 'view/view.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/view/view.dart
|
export 'exercise_list_page.dart';
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/view/exercise_list_page.dart
|
import 'package:body_api/body_api.dart';
import 'package:exercise_repository/exercise_repository.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
import 'package:go_router/go_router.dart';
class ExerciseListPage extends StatelessWidget {
const ExerciseListPage({required this.extra, super.key});
final ExerciseListExtra extra;
static String name = '/exercise-list';
static String path = name;
@override
Widget build(BuildContext context) {
return BlocProvider(
create: (context) => ExerciseListBloc(
exerciseRepository: context.read<ExerciseRepository>(),
extra: extra,
)..add(const ExerciseListSubscriptionRequested()),
child: const ExerciseListView(),
);
}
}
class ExerciseListView extends StatelessWidget {
const ExerciseListView({super.key});
@override
Widget build(BuildContext context) {
return BlocConsumer<ExerciseListBloc, ExerciseListState>(
listenWhen: (previous, current) => previous.status != current.status,
listener: (context, state) {
if (state.status == ExerciseListStatus.confirm) {
context.pop();
}
},
buildWhen: (previous, current) =>
previous.status != current.status ||
previous.isSearching != current.isSearching,
builder: (context, state) {
switch (state.status) {
case ExerciseListStatus.failure:
return const AppScaffold(body: AppError());
case ExerciseListStatus.initial:
case ExerciseListStatus.loading:
return const AppScaffold(body: AppLoading());
case ExerciseListStatus.confirm:
case ExerciseListStatus.success:
return AppScaffold(
title: context.locale.exercises,
customTitle: state.isSearching ? const _SearchBar() : null,
floatingActionButton: const _ConfirmFab(),
actions: const [_SearchButton()],
body: Column(
children: const [
_SettingsRow(),
_ExerciseList(),
],
),
);
}
},
);
}
}
class _SettingsRow extends StatelessWidget {
const _SettingsRow();
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.symmetric(
horizontal: 16,
vertical: 8,
),
child: Row(
children: const [
_MuscleButton(),
SizedBox(width: 8),
_CategoryButton(),
],
),
);
}
}
class _MuscleButton extends StatelessWidget {
const _MuscleButton();
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseListBloc, ExerciseListState>(
buildWhen: (previous, current) => previous.muscle != current.muscle,
builder: (context, state) {
final muscle = state.muscle;
return Flexible(
fit: FlexFit.tight,
child: CustomBar(
onTap: () async {
final bloc = context.read<ExerciseListBloc>();
await showDialog<String>(
context: context,
builder: (context) => _MuscleDialog(
muscle: muscle,
onConfirm: (muscle) =>
bloc.add(ExerciseListMuscle(muscle: muscle)),
),
);
},
child: Center(
child: Text(
context.locale.muscle(muscle?.name ?? ''),
style: AppTextStyle.semiBold20,
),
),
),
);
},
);
}
}
class _MuscleDialog extends StatefulWidget {
const _MuscleDialog({
required this.onConfirm,
this.muscle,
});
final Muscle? muscle;
final ValueChanged<Muscle?> onConfirm;
@override
State<_MuscleDialog> createState() => _MuscleDialogState();
}
class _MuscleDialogState extends State<_MuscleDialog> {
Muscle? selectedMuscle;
@override
void initState() {
selectedMuscle = widget.muscle;
super.initState();
}
@override
Widget build(BuildContext context) {
return FractionallySizedBox(
heightFactor: 0.5,
widthFactor: 1,
child: CustomDialog(
title: context.locale.pickMuscle,
content: SingleChildScrollView(
physics: const BouncingScrollPhysics(),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
_buildTile(muscle: null),
...Muscle.values.map<Widget>(
(m) => _buildTile(muscle: m),
)
],
),
),
onConfirm: () => widget.onConfirm(selectedMuscle),
),
);
}
Widget _buildTile({required Muscle? muscle}) {
return RadioListTile<Muscle?>(
title: Text(context.locale.muscle(muscle?.name ?? '')),
value: muscle,
groupValue: selectedMuscle,
onChanged: (value) => setState(() {
selectedMuscle = value;
}),
);
}
}
class _CategoryButton extends StatelessWidget {
const _CategoryButton();
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseListBloc, ExerciseListState>(
buildWhen: (previous, current) => previous.category != current.category,
builder: (context, state) {
final category = state.category;
return Flexible(
fit: FlexFit.tight,
child: CustomBar(
onTap: () async {
final bloc = context.read<ExerciseListBloc>();
await showDialog<String>(
context: context,
builder: (context) => _CategoryDialog(
category: category,
onConfirm: (category) =>
bloc.add(ExerciseListCategory(category: category)),
),
);
},
child: Center(
child: Text(
context.locale.exerciseCategory(category?.name ?? ''),
style: AppTextStyle.semiBold20,
),
),
),
);
},
);
}
}
class _CategoryDialog extends StatefulWidget {
const _CategoryDialog({
required this.onConfirm,
this.category,
});
final ExerciseCategory? category;
final ValueChanged<ExerciseCategory?> onConfirm;
@override
State<_CategoryDialog> createState() => _CategoryDialogState();
}
class _CategoryDialogState extends State<_CategoryDialog> {
ExerciseCategory? category;
@override
void initState() {
category = widget.category;
super.initState();
}
@override
Widget build(BuildContext context) {
return FractionallySizedBox(
heightFactor: 0.5,
widthFactor: 1,
child: CustomDialog(
title: context.locale.pickCategory,
content: SingleChildScrollView(
physics: const BouncingScrollPhysics(),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
_buildTile(value: null),
...ExerciseCategory.values.map<Widget>(
(c) => _buildTile(value: c),
)
],
),
),
onConfirm: () => widget.onConfirm(category),
),
);
}
Widget _buildTile({required ExerciseCategory? value}) {
return RadioListTile<ExerciseCategory?>(
title: Text(context.locale.exerciseCategory(value?.name ?? '')),
value: value,
groupValue: category,
onChanged: (value) => setState(() {
category = value;
}),
);
}
}
class _ConfirmFab extends StatelessWidget {
const _ConfirmFab();
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseListBloc, ExerciseListState>(
builder: (context, state) {
final lenght = state.selected.values.where((element) => element).length;
if (lenght < 1) {
return Container();
}
switch (state.extra.selectionType) {
case SelectionType.none:
return Container();
case SelectionType.single:
return FloatingActionButton(
child: state.extra.icon,
onPressed: () {
context
.read<ExerciseListBloc>()
.add(const ExerciseListConfirm());
},
);
case SelectionType.multiple:
return FloatingActionButton.extended(
label: Text(
// 'Add $lenght exercises',
context.locale.addExercisesCount(lenght),
style: AppTextStyle.semiBold16,
),
onPressed: () {
context
.read<ExerciseListBloc>()
.add(const ExerciseListConfirm());
},
);
}
},
);
}
}
class _ExerciseList extends StatelessWidget {
const _ExerciseList();
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseListBloc, ExerciseListState>(
builder: (context, state) {
final list = state.data;
// TODO(UI): Animated list
return Expanded(
child: ListView(
shrinkWrap: true,
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
physics: const BouncingScrollPhysics(),
children: list.map<Widget>((exercise) {
final isSelected = state.selected[exercise] ?? false;
return ExerciseItem(
exercise: exercise,
isSelected: isSelected,
onTap: () {
if (state.extra.selectionType == SelectionType.none) {
context.pushNamed(
ExerciseStatsPage.name,
params: {'exerciseId': exercise.id},
);
} else {
context
.read<ExerciseListBloc>()
.add(ExerciseListSelect(exercise: exercise));
}
},
onIconPressed: () {
context.pushNamed(
ExerciseDetailsPage.name,
params: {'exerciseId': exercise.id},
);
},
);
}).toList(),
),
);
},
);
}
}
class _SearchButton extends StatelessWidget {
const _SearchButton();
@override
Widget build(BuildContext context) {
return BlocBuilder<ExerciseListBloc, ExerciseListState>(
buildWhen: (previous, current) =>
previous.isSearching != current.isSearching,
builder: (context, state) {
return Visibility(
visible: !state.isSearching,
child: IconButton(
onPressed: () {
context
.read<ExerciseListBloc>()
.add(const ExerciseListFilter(filter: ''));
},
icon: const AppIcon(iconData: AppIcons.search),
),
);
},
);
}
}
class _SearchBar extends StatelessWidget {
const _SearchBar();
@override
Widget build(BuildContext context) {
return TextField(
decoration: InputDecoration(
floatingLabelBehavior: FloatingLabelBehavior.never,
labelText: context.locale.search,
prefixIcon: const AppIcon(iconData: AppIcons.search),
suffixIcon: IconButton(
onPressed: () {
context
.read<ExerciseListBloc>()
.add(const ExerciseListFilterCancel());
},
// TODO(Icon): Cancel searching icon
icon: const AppIcon(iconData: AppIcons.stop),
),
),
onChanged: (value) => context
.read<ExerciseListBloc>()
.add(ExerciseListFilter(filter: value)),
onSubmitted: (value) {
if (value.isEmpty) {
context
.read<ExerciseListBloc>()
.add(const ExerciseListFilterCancel());
}
},
);
}
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/models/exercise_list_extra.dart
|
import 'package:exercise_api/exercise_api.dart';
import 'package:future_of_workout/src/common.dart';
import 'package:future_of_workout/src/exercise/exercise.dart';
class ExerciseListExtra {
ExerciseListExtra({
this.onConfirm,
this.selectionType = SelectionType.single,
this.icon = const AppIcon(iconData: AppIcons.repeat),
});
final Future<void> Function(List<Exercise> selected)? onConfirm;
final SelectionType selectionType;
final AppIcon? icon;
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/models/exercise_category.dart
|
enum ExerciseCategory {
bodyweight,
weight,
machine,
cable,
}
| 0
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list
|
mirrored_repositories/future_of_workout/lib/src/exercise/exercise_list/models/models.dart
|
export 'exercise_category.dart';
export 'exercise_list_extra.dart';
export 'selection_type.dart';
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.