Rijad Zuzo
2332 lines
71 KiB
Dart
2332 lines
71 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:relationship_saver/core/config/app_theme.dart';
|
|
import 'package:relationship_saver/features/local/local_models.dart';
|
|
import 'package:relationship_saver/features/local/local_repository.dart';
|
|
import 'package:relationship_saver/features/shared/frosted_card.dart';
|
|
|
|
class SelectedPersonIdNotifier extends Notifier<String?> {
|
|
@override
|
|
String? build() => null;
|
|
|
|
void select(String id) {
|
|
state = id;
|
|
}
|
|
|
|
void clear() {
|
|
state = null;
|
|
}
|
|
}
|
|
|
|
final NotifierProvider<SelectedPersonIdNotifier, String?>
|
|
selectedPersonIdProvider = NotifierProvider<SelectedPersonIdNotifier, String?>(
|
|
SelectedPersonIdNotifier.new,
|
|
);
|
|
|
|
enum PeopleSortOption { affinity, nextMoment, alphabetical }
|
|
|
|
class PeopleSearchQueryNotifier extends Notifier<String> {
|
|
@override
|
|
String build() => '';
|
|
|
|
void set(String value) {
|
|
state = value;
|
|
}
|
|
}
|
|
|
|
final NotifierProvider<PeopleSearchQueryNotifier, String>
|
|
peopleSearchQueryProvider = NotifierProvider<PeopleSearchQueryNotifier, String>(
|
|
PeopleSearchQueryNotifier.new,
|
|
);
|
|
|
|
class PeopleRelationshipFilterNotifier extends Notifier<String?> {
|
|
@override
|
|
String? build() => null;
|
|
|
|
void set(String? value) {
|
|
state = value;
|
|
}
|
|
}
|
|
|
|
final NotifierProvider<PeopleRelationshipFilterNotifier, String?>
|
|
peopleRelationshipFilterProvider =
|
|
NotifierProvider<PeopleRelationshipFilterNotifier, String?>(
|
|
PeopleRelationshipFilterNotifier.new,
|
|
);
|
|
|
|
class PeopleSortOptionNotifier extends Notifier<PeopleSortOption> {
|
|
@override
|
|
PeopleSortOption build() => PeopleSortOption.affinity;
|
|
|
|
void set(PeopleSortOption value) {
|
|
state = value;
|
|
}
|
|
}
|
|
|
|
final NotifierProvider<PeopleSortOptionNotifier, PeopleSortOption>
|
|
peopleSortOptionProvider =
|
|
NotifierProvider<PeopleSortOptionNotifier, PeopleSortOption>(
|
|
PeopleSortOptionNotifier.new,
|
|
);
|
|
|
|
enum _PersonQuickAction { capture, note, idea, reminder }
|
|
|
|
class PeopleView extends ConsumerWidget {
|
|
const PeopleView({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final AsyncValue<LocalDataState> localData = ref.watch(
|
|
localRepositoryProvider,
|
|
);
|
|
final String searchQuery = ref.watch(peopleSearchQueryProvider);
|
|
final String? relationshipFilter = ref.watch(
|
|
peopleRelationshipFilterProvider,
|
|
);
|
|
final PeopleSortOption sortOption = ref.watch(peopleSortOptionProvider);
|
|
|
|
return localData.when(
|
|
data: (LocalDataState data) {
|
|
final List<PersonProfile> allPeople = data.people;
|
|
if (allPeople.isEmpty) {
|
|
return _EmptyPeopleView(onAdd: () => _handleAddPerson(context, ref));
|
|
}
|
|
|
|
final List<PersonProfile> people = _applyPeopleFilters(
|
|
allPeople,
|
|
searchQuery: searchQuery,
|
|
relationshipFilter: relationshipFilter,
|
|
sortOption: sortOption,
|
|
);
|
|
final List<String> relationshipOptions = _relationshipOptions(
|
|
allPeople,
|
|
);
|
|
|
|
if (people.isEmpty) {
|
|
return _FilteredPeopleEmptyView(
|
|
onClear: () {
|
|
ref.read(peopleSearchQueryProvider.notifier).set('');
|
|
ref.read(peopleRelationshipFilterProvider.notifier).set(null);
|
|
},
|
|
);
|
|
}
|
|
|
|
final String selectedId =
|
|
ref.watch(selectedPersonIdProvider) ?? people.first.id;
|
|
final PersonProfile selected = people.firstWhere(
|
|
(PersonProfile person) => person.id == selectedId,
|
|
orElse: () => people.first,
|
|
);
|
|
|
|
return LayoutBuilder(
|
|
builder: (BuildContext context, BoxConstraints constraints) {
|
|
final bool isCompact = constraints.maxWidth < 860;
|
|
if (isCompact) {
|
|
return _buildCompactLayout(
|
|
context,
|
|
ref,
|
|
data,
|
|
people,
|
|
selected,
|
|
relationshipOptions,
|
|
);
|
|
}
|
|
return _buildWideLayout(
|
|
context,
|
|
ref,
|
|
data,
|
|
people,
|
|
selected,
|
|
relationshipOptions,
|
|
);
|
|
},
|
|
);
|
|
},
|
|
loading: () => const Center(child: CircularProgressIndicator()),
|
|
error: (Object error, StackTrace stackTrace) {
|
|
return const Center(child: Text('Unable to load people'));
|
|
},
|
|
);
|
|
}
|
|
|
|
List<PersonProfile> _applyPeopleFilters(
|
|
List<PersonProfile> people, {
|
|
required String searchQuery,
|
|
required String? relationshipFilter,
|
|
required PeopleSortOption sortOption,
|
|
}) {
|
|
final String query = searchQuery.trim().toLowerCase();
|
|
final String? relationship = relationshipFilter?.trim().toLowerCase();
|
|
|
|
final List<PersonProfile> filtered = people
|
|
.where((PersonProfile person) {
|
|
if (relationship != null &&
|
|
relationship.isNotEmpty &&
|
|
person.relationship.trim().toLowerCase() != relationship) {
|
|
return false;
|
|
}
|
|
if (query.isEmpty) {
|
|
return true;
|
|
}
|
|
final String haystack = <String>[
|
|
person.name,
|
|
person.relationship,
|
|
person.location ?? '',
|
|
person.notes,
|
|
...person.tags,
|
|
].join(' ').toLowerCase();
|
|
return haystack.contains(query);
|
|
})
|
|
.toList(growable: true);
|
|
|
|
filtered.sort((PersonProfile a, PersonProfile b) {
|
|
switch (sortOption) {
|
|
case PeopleSortOption.affinity:
|
|
final int score = b.affinityScore.compareTo(a.affinityScore);
|
|
if (score != 0) {
|
|
return score;
|
|
}
|
|
return a.name.toLowerCase().compareTo(b.name.toLowerCase());
|
|
case PeopleSortOption.nextMoment:
|
|
final int next = a.nextMoment.compareTo(b.nextMoment);
|
|
if (next != 0) {
|
|
return next;
|
|
}
|
|
return a.name.toLowerCase().compareTo(b.name.toLowerCase());
|
|
case PeopleSortOption.alphabetical:
|
|
return a.name.toLowerCase().compareTo(b.name.toLowerCase());
|
|
}
|
|
});
|
|
|
|
return filtered;
|
|
}
|
|
|
|
List<String> _relationshipOptions(List<PersonProfile> people) {
|
|
final Set<String> seen = <String>{};
|
|
final List<String> values = <String>[];
|
|
for (final PersonProfile person in people) {
|
|
final String relationship = person.relationship.trim();
|
|
if (relationship.isEmpty) {
|
|
continue;
|
|
}
|
|
final String key = relationship.toLowerCase();
|
|
if (seen.add(key)) {
|
|
values.add(relationship);
|
|
}
|
|
}
|
|
values.sort(
|
|
(String a, String b) => a.toLowerCase().compareTo(b.toLowerCase()),
|
|
);
|
|
return values;
|
|
}
|
|
|
|
Future<void> _handleAddPerson(BuildContext context, WidgetRef ref) async {
|
|
final _PersonDraft? draft = await showDialog<_PersonDraft>(
|
|
context: context,
|
|
builder: (BuildContext context) =>
|
|
const _PersonEditorDialog(title: 'Add Person'),
|
|
);
|
|
|
|
if (draft == null) {
|
|
return;
|
|
}
|
|
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.addPerson(
|
|
name: draft.name,
|
|
relationship: draft.relationship,
|
|
notes: draft.notes,
|
|
tags: draft.tags,
|
|
location: draft.location,
|
|
);
|
|
|
|
final LocalDataState? latest = ref
|
|
.read(localRepositoryProvider)
|
|
.asData
|
|
?.value;
|
|
if (latest == null) {
|
|
return;
|
|
}
|
|
for (final PersonProfile person in latest.people) {
|
|
final bool locationMatches =
|
|
(person.location ?? '').trim() == (draft.location ?? '').trim();
|
|
if (person.name == draft.name &&
|
|
person.relationship == draft.relationship &&
|
|
locationMatches) {
|
|
ref.read(selectedPersonIdProvider.notifier).select(person.id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _handleEditPerson(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
PersonProfile person,
|
|
) async {
|
|
final _PersonDraft? draft = await showDialog<_PersonDraft>(
|
|
context: context,
|
|
builder: (BuildContext context) => _PersonEditorDialog(
|
|
title: 'Edit Person',
|
|
initial: _PersonDraft(
|
|
name: person.name,
|
|
relationship: person.relationship,
|
|
notes: person.notes,
|
|
tags: person.tags,
|
|
location: person.location,
|
|
),
|
|
),
|
|
);
|
|
|
|
if (draft == null) {
|
|
return;
|
|
}
|
|
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.updatePerson(
|
|
person.copyWith(
|
|
name: draft.name,
|
|
relationship: draft.relationship,
|
|
notes: draft.notes,
|
|
tags: draft.tags,
|
|
location: draft.location,
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _handleDeletePerson(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
String personId,
|
|
) async {
|
|
final bool? confirmed = await showDialog<bool>(
|
|
context: context,
|
|
builder: (BuildContext context) {
|
|
return AlertDialog(
|
|
title: const Text('Delete person?'),
|
|
content: const Text(
|
|
'This will remove the person and related moments from local storage.',
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(false),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () => Navigator.of(context).pop(true),
|
|
child: const Text('Delete'),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
|
|
if (confirmed != true) {
|
|
return;
|
|
}
|
|
|
|
await ref.read(localRepositoryProvider.notifier).deletePerson(personId);
|
|
ref.read(selectedPersonIdProvider.notifier).clear();
|
|
}
|
|
|
|
Widget _buildWideLayout(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
LocalDataState data,
|
|
List<PersonProfile> people,
|
|
PersonProfile selected,
|
|
List<String> relationshipOptions,
|
|
) {
|
|
return Padding(
|
|
padding: const EdgeInsets.fromLTRB(28, 24, 28, 28),
|
|
child: Row(
|
|
children: <Widget>[
|
|
Expanded(
|
|
flex: 5,
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
_PeopleHeader(
|
|
onAdd: () => _handleAddPerson(context, ref),
|
|
onMerge: () => _handleMergePeople(context, ref, people),
|
|
compact: false,
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleListControls(
|
|
compact: false,
|
|
relationshipOptions: relationshipOptions,
|
|
),
|
|
const SizedBox(height: 20),
|
|
Expanded(
|
|
child: ListView.separated(
|
|
itemCount: people.length,
|
|
separatorBuilder: (_, _) => const SizedBox(height: 12),
|
|
itemBuilder: (BuildContext context, int index) {
|
|
final PersonProfile person = people[index];
|
|
return _PersonListItem(
|
|
person: person,
|
|
selectedId: selected.id,
|
|
compact: false,
|
|
onSelect: () {
|
|
ref
|
|
.read(selectedPersonIdProvider.notifier)
|
|
.select(person.id);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(width: 18),
|
|
Expanded(
|
|
flex: 6,
|
|
child: FrostedCard(
|
|
child: SingleChildScrollView(
|
|
child: _PersonDetail(
|
|
person: selected,
|
|
data: data,
|
|
onEdit: () => _handleEditPerson(context, ref, selected),
|
|
onDelete: () =>
|
|
_handleDeletePerson(context, ref, selected.id),
|
|
onQuickAction: (_PersonQuickAction action) =>
|
|
_handleQuickAction(context, ref, selected, action),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildCompactLayout(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
LocalDataState data,
|
|
List<PersonProfile> people,
|
|
PersonProfile selected,
|
|
List<String> relationshipOptions,
|
|
) {
|
|
return Padding(
|
|
padding: const EdgeInsets.fromLTRB(18, 16, 18, 20),
|
|
child: ListView(
|
|
children: <Widget>[
|
|
_PeopleHeader(
|
|
onAdd: () => _handleAddPerson(context, ref),
|
|
onMerge: () => _handleMergePeople(context, ref, people),
|
|
compact: true,
|
|
),
|
|
const SizedBox(height: 10),
|
|
_PeopleListControls(
|
|
compact: true,
|
|
relationshipOptions: relationshipOptions,
|
|
),
|
|
const SizedBox(height: 14),
|
|
FrostedCard(
|
|
child: _PersonDetail(
|
|
person: selected,
|
|
data: data,
|
|
compact: true,
|
|
onEdit: () => _handleEditPerson(context, ref, selected),
|
|
onDelete: () => _handleDeletePerson(context, ref, selected.id),
|
|
onQuickAction: (_PersonQuickAction action) =>
|
|
_handleQuickAction(context, ref, selected, action),
|
|
),
|
|
),
|
|
const SizedBox(height: 14),
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 2),
|
|
child: Row(
|
|
children: <Widget>[
|
|
Text(
|
|
'All profiles',
|
|
style: Theme.of(context).textTheme.titleMedium,
|
|
),
|
|
const Spacer(),
|
|
Text(
|
|
'${people.length}',
|
|
style: Theme.of(context).textTheme.labelLarge?.copyWith(
|
|
color: AppTheme.textSecondary,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(height: 10),
|
|
...people.map(
|
|
(PersonProfile person) => Padding(
|
|
padding: const EdgeInsets.only(bottom: 10),
|
|
child: _PersonListItem(
|
|
person: person,
|
|
selectedId: selected.id,
|
|
compact: true,
|
|
onSelect: () {
|
|
ref.read(selectedPersonIdProvider.notifier).select(person.id);
|
|
},
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _handleQuickAction(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
PersonProfile person,
|
|
_PersonQuickAction action,
|
|
) async {
|
|
switch (action) {
|
|
case _PersonQuickAction.capture:
|
|
final String? summary = await _showQuickTextCaptureDialog(
|
|
context,
|
|
title: 'Add Capture',
|
|
hintText: 'What happened in this interaction?',
|
|
);
|
|
if (summary == null) {
|
|
return;
|
|
}
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.addMoment(personId: person.id, summary: summary, type: 'capture');
|
|
return;
|
|
case _PersonQuickAction.note:
|
|
final String? note = await _showQuickTextCaptureDialog(
|
|
context,
|
|
title: 'Add Note',
|
|
hintText: 'Write a quick context note...',
|
|
);
|
|
if (note == null) {
|
|
return;
|
|
}
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.addMoment(personId: person.id, summary: note, type: 'note');
|
|
return;
|
|
case _PersonQuickAction.idea:
|
|
final _QuickIdeaDraft? idea = await showDialog<_QuickIdeaDraft>(
|
|
context: context,
|
|
builder: (BuildContext context) => const _QuickIdeaDialog(),
|
|
);
|
|
if (idea == null) {
|
|
return;
|
|
}
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.addIdea(
|
|
type: idea.type,
|
|
title: idea.title,
|
|
details: idea.details,
|
|
personId: person.id,
|
|
);
|
|
return;
|
|
case _PersonQuickAction.reminder:
|
|
final _QuickReminderDraft? reminder =
|
|
await showDialog<_QuickReminderDraft>(
|
|
context: context,
|
|
builder: (BuildContext context) => const _QuickReminderDialog(),
|
|
);
|
|
if (reminder == null) {
|
|
return;
|
|
}
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.addReminder(
|
|
title: reminder.title,
|
|
cadence: reminder.cadence,
|
|
nextAt: reminder.nextAt,
|
|
personId: person.id,
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
|
|
Future<void> _handleMergePeople(
|
|
BuildContext context,
|
|
WidgetRef ref,
|
|
List<PersonProfile> people,
|
|
) async {
|
|
if (people.length < 2) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('Need at least two profiles to merge.')),
|
|
);
|
|
return;
|
|
}
|
|
|
|
final List<PersonProfile> duplicateCandidates = _duplicateCandidates(
|
|
people,
|
|
);
|
|
if (duplicateCandidates.length < 2) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text(
|
|
'No duplicate-name profiles found. Edit names first if needed.',
|
|
),
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
|
|
final _MergePeopleDraft? draft = await showDialog<_MergePeopleDraft>(
|
|
context: context,
|
|
builder: (BuildContext context) =>
|
|
_MergePeopleDialog(people: duplicateCandidates),
|
|
);
|
|
if (draft == null) {
|
|
return;
|
|
}
|
|
|
|
await ref
|
|
.read(localRepositoryProvider.notifier)
|
|
.mergePersonProfiles(
|
|
sourcePersonId: draft.sourcePersonId,
|
|
targetPersonId: draft.targetPersonId,
|
|
);
|
|
ref.read(selectedPersonIdProvider.notifier).select(draft.targetPersonId);
|
|
if (!context.mounted) {
|
|
return;
|
|
}
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('Profiles merged successfully.')),
|
|
);
|
|
}
|
|
|
|
List<PersonProfile> _duplicateCandidates(List<PersonProfile> people) {
|
|
final Map<String, List<PersonProfile>> grouped =
|
|
<String, List<PersonProfile>>{};
|
|
for (final PersonProfile person in people) {
|
|
final String key = _normalizeNameKey(person.name);
|
|
if (key.isEmpty) {
|
|
continue;
|
|
}
|
|
grouped.putIfAbsent(key, () => <PersonProfile>[]).add(person);
|
|
}
|
|
final List<PersonProfile> result = <PersonProfile>[];
|
|
for (final List<PersonProfile> group in grouped.values) {
|
|
if (group.length > 1) {
|
|
result.addAll(group);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
String _normalizeNameKey(String value) {
|
|
return value
|
|
.trim()
|
|
.toLowerCase()
|
|
.replaceAll(RegExp(r'[^a-z0-9]+'), ' ')
|
|
.replaceAll(RegExp(r'\s+'), ' ');
|
|
}
|
|
|
|
Future<String?> _showQuickTextCaptureDialog(
|
|
BuildContext context, {
|
|
required String title,
|
|
required String hintText,
|
|
}) async {
|
|
final TextEditingController controller = TextEditingController();
|
|
final String? result = await showDialog<String>(
|
|
context: context,
|
|
builder: (BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(title),
|
|
content: TextField(
|
|
controller: controller,
|
|
minLines: 2,
|
|
maxLines: 4,
|
|
decoration: InputDecoration(hintText: hintText),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () {
|
|
final String value = controller.text.trim();
|
|
if (value.isEmpty) {
|
|
return;
|
|
}
|
|
Navigator.of(context).pop(value);
|
|
},
|
|
child: const Text('Save'),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
controller.dispose();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class _EmptyPeopleView extends StatelessWidget {
|
|
const _EmptyPeopleView({required this.onAdd});
|
|
|
|
final VoidCallback onAdd;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Center(
|
|
child: FrostedCard(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
Text(
|
|
'No people yet',
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
'Add the first relationship profile to start tracking moments.',
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyLarge?.copyWith(color: AppTheme.textSecondary),
|
|
textAlign: TextAlign.center,
|
|
),
|
|
const SizedBox(height: 12),
|
|
FilledButton.icon(
|
|
onPressed: onAdd,
|
|
icon: const Icon(Icons.person_add_alt_1_rounded),
|
|
label: const Text('Add Person'),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _FilteredPeopleEmptyView extends StatelessWidget {
|
|
const _FilteredPeopleEmptyView({required this.onClear});
|
|
|
|
final VoidCallback onClear;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Center(
|
|
child: FrostedCard(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
const Icon(
|
|
Icons.search_off_rounded,
|
|
size: 34,
|
|
color: AppTheme.textSecondary,
|
|
),
|
|
const SizedBox(height: 10),
|
|
Text(
|
|
'No matching people',
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
'Try another search, relationship filter, or clear the current filters.',
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyLarge?.copyWith(color: AppTheme.textSecondary),
|
|
textAlign: TextAlign.center,
|
|
),
|
|
const SizedBox(height: 12),
|
|
OutlinedButton.icon(
|
|
onPressed: onClear,
|
|
icon: const Icon(Icons.restart_alt_rounded),
|
|
label: const Text('Clear Filters'),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleListControls extends ConsumerWidget {
|
|
const _PeopleListControls({
|
|
required this.compact,
|
|
required this.relationshipOptions,
|
|
});
|
|
|
|
final bool compact;
|
|
final List<String> relationshipOptions;
|
|
|
|
@override
|
|
Widget build(BuildContext context, WidgetRef ref) {
|
|
final String query = ref.watch(peopleSearchQueryProvider);
|
|
final String? selectedRelationship = ref.watch(
|
|
peopleRelationshipFilterProvider,
|
|
);
|
|
final PeopleSortOption sortOption = ref.watch(peopleSortOptionProvider);
|
|
|
|
return FrostedCard(
|
|
padding: EdgeInsets.all(compact ? 12 : 14),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Row(
|
|
children: <Widget>[
|
|
Expanded(
|
|
child: TextFormField(
|
|
key: ValueKey<String>('people-search-$query'),
|
|
initialValue: query,
|
|
onChanged: (String value) {
|
|
ref.read(peopleSearchQueryProvider.notifier).set(value);
|
|
},
|
|
decoration: const InputDecoration(
|
|
hintText: 'Search name, tags, notes, location',
|
|
prefixIcon: Icon(Icons.search_rounded),
|
|
isDense: true,
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
PopupMenuButton<PeopleSortOption>(
|
|
tooltip: 'Sort',
|
|
onSelected: (PeopleSortOption value) {
|
|
ref.read(peopleSortOptionProvider.notifier).set(value);
|
|
},
|
|
itemBuilder: (BuildContext context) =>
|
|
<PopupMenuEntry<PeopleSortOption>>[
|
|
const PopupMenuItem<PeopleSortOption>(
|
|
value: PeopleSortOption.affinity,
|
|
child: Text('Sort by affinity'),
|
|
),
|
|
const PopupMenuItem<PeopleSortOption>(
|
|
value: PeopleSortOption.nextMoment,
|
|
child: Text('Sort by next moment'),
|
|
),
|
|
const PopupMenuItem<PeopleSortOption>(
|
|
value: PeopleSortOption.alphabetical,
|
|
child: Text('Sort A-Z'),
|
|
),
|
|
],
|
|
child: Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 10,
|
|
vertical: 10,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFF3F8FB),
|
|
borderRadius: BorderRadius.circular(12),
|
|
),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
const Icon(Icons.sort_rounded, size: 18),
|
|
if (!compact) ...<Widget>[
|
|
const SizedBox(width: 6),
|
|
Text(switch (sortOption) {
|
|
PeopleSortOption.affinity => 'Affinity',
|
|
PeopleSortOption.nextMoment => 'Next',
|
|
PeopleSortOption.alphabetical => 'A-Z',
|
|
}),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 10),
|
|
SingleChildScrollView(
|
|
scrollDirection: Axis.horizontal,
|
|
child: Row(
|
|
children: <Widget>[
|
|
_FilterChipButton(
|
|
label: 'All',
|
|
selected: selectedRelationship == null,
|
|
onTap: () {
|
|
ref
|
|
.read(peopleRelationshipFilterProvider.notifier)
|
|
.set(null);
|
|
},
|
|
),
|
|
...relationshipOptions.map(
|
|
(String relationship) => Padding(
|
|
padding: const EdgeInsets.only(left: 8),
|
|
child: _FilterChipButton(
|
|
label: relationship,
|
|
selected:
|
|
selectedRelationship?.toLowerCase() ==
|
|
relationship.toLowerCase(),
|
|
onTap: () {
|
|
final PeopleRelationshipFilterNotifier controller = ref
|
|
.read(peopleRelationshipFilterProvider.notifier);
|
|
final bool isSelected =
|
|
selectedRelationship?.toLowerCase() ==
|
|
relationship.toLowerCase();
|
|
controller.set(isSelected ? null : relationship);
|
|
},
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _FilterChipButton extends StatelessWidget {
|
|
const _FilterChipButton({
|
|
required this.label,
|
|
required this.selected,
|
|
required this.onTap,
|
|
});
|
|
|
|
final String label;
|
|
final bool selected;
|
|
final VoidCallback onTap;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return InkWell(
|
|
onTap: onTap,
|
|
borderRadius: BorderRadius.circular(99),
|
|
child: Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
|
|
decoration: BoxDecoration(
|
|
color: selected ? const Color(0xFFEAF7FB) : const Color(0xFFF4F8FB),
|
|
borderRadius: BorderRadius.circular(99),
|
|
border: Border.all(
|
|
color: selected
|
|
? const Color(0xFFB8E4EE)
|
|
: Colors.white.withValues(alpha: 0.8),
|
|
),
|
|
),
|
|
child: Text(
|
|
label,
|
|
style: Theme.of(context).textTheme.labelLarge?.copyWith(
|
|
color: selected ? AppTheme.primary : AppTheme.textSecondary,
|
|
fontWeight: selected ? FontWeight.w700 : FontWeight.w500,
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonDetail extends StatelessWidget {
|
|
const _PersonDetail({
|
|
required this.person,
|
|
required this.data,
|
|
required this.onEdit,
|
|
required this.onDelete,
|
|
required this.onQuickAction,
|
|
this.compact = false,
|
|
});
|
|
|
|
final PersonProfile person;
|
|
final LocalDataState data;
|
|
final VoidCallback onEdit;
|
|
final VoidCallback onDelete;
|
|
final ValueChanged<_PersonQuickAction> onQuickAction;
|
|
final bool compact;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final List<RelationshipMoment> moments =
|
|
data.moments
|
|
.where((RelationshipMoment moment) => moment.personId == person.id)
|
|
.toList(growable: false)
|
|
..sort(
|
|
(RelationshipMoment a, RelationshipMoment b) =>
|
|
b.at.compareTo(a.at),
|
|
);
|
|
final List<RelationshipIdea> ideas =
|
|
data.ideas
|
|
.where((RelationshipIdea idea) => idea.personId == person.id)
|
|
.toList(growable: false)
|
|
..sort(
|
|
(RelationshipIdea a, RelationshipIdea b) =>
|
|
b.createdAt.compareTo(a.createdAt),
|
|
);
|
|
final List<ReminderRule> reminders =
|
|
data.reminders
|
|
.where((ReminderRule reminder) => reminder.personId == person.id)
|
|
.toList(growable: false)
|
|
..sort(
|
|
(ReminderRule a, ReminderRule b) => a.nextAt.compareTo(b.nextAt),
|
|
);
|
|
final List<SharedMessageEntry> sharedMessages =
|
|
data.sharedMessages
|
|
.where((SharedMessageEntry entry) => entry.profileId == person.id)
|
|
.toList(growable: false)
|
|
..sort(
|
|
(SharedMessageEntry a, SharedMessageEntry b) =>
|
|
b.sharedAt.compareTo(a.sharedAt),
|
|
);
|
|
final List<SourceProfileLink> sourceLinks =
|
|
data.sourceLinks
|
|
.where((SourceProfileLink link) => link.profileId == person.id)
|
|
.toList(growable: false)
|
|
..sort(
|
|
(SourceProfileLink a, SourceProfileLink b) =>
|
|
b.lastSeenAt.compareTo(a.lastSeenAt),
|
|
);
|
|
final bool hasNotes = person.notes.trim().isNotEmpty;
|
|
final String? location = person.location?.trim().isEmpty ?? true
|
|
? null
|
|
: person.location!.trim();
|
|
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
_PersonWorkspaceHero(
|
|
person: person,
|
|
compact: compact,
|
|
sourceLinks: sourceLinks,
|
|
onEdit: onEdit,
|
|
onDelete: onDelete,
|
|
onQuickAction: onQuickAction,
|
|
),
|
|
SizedBox(height: compact ? 12 : 14),
|
|
Wrap(
|
|
spacing: 10,
|
|
runSpacing: 10,
|
|
children: <Widget>[
|
|
_PersonStatTile(
|
|
label: 'Affinity',
|
|
value: '${person.affinityScore}%',
|
|
accent: const Color(0xFF1AB6C8),
|
|
compact: compact,
|
|
),
|
|
_PersonStatTile(
|
|
label: 'Next moment',
|
|
value: _dateTimeLabel(person.nextMoment),
|
|
accent: const Color(0xFF2274E0),
|
|
compact: compact,
|
|
),
|
|
_PersonStatTile(
|
|
label: 'Captures',
|
|
value: '${moments.length}',
|
|
accent: const Color(0xFF23A26D),
|
|
compact: compact,
|
|
),
|
|
_PersonStatTile(
|
|
label: 'Ideas',
|
|
value:
|
|
'${ideas.where((RelationshipIdea e) => !e.isArchived).length}',
|
|
accent: const Color(0xFFF4A524),
|
|
compact: compact,
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleInsightSectionCard(
|
|
title: 'Profile context',
|
|
icon: Icons.person_outline_rounded,
|
|
children: <Widget>[
|
|
Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
children: <Widget>[
|
|
_InlineMetaPill(
|
|
icon: Icons.favorite_outline_rounded,
|
|
label: person.relationship,
|
|
),
|
|
if (location != null)
|
|
_InlineMetaPill(
|
|
icon: Icons.location_on_outlined,
|
|
label: location,
|
|
),
|
|
if (sourceLinks.isNotEmpty)
|
|
_InlineMetaPill(
|
|
icon: Icons.link_rounded,
|
|
label:
|
|
'${sourceLinks.length} linked source${sourceLinks.length == 1 ? '' : 's'}',
|
|
),
|
|
...person.tags.map(
|
|
(String tag) =>
|
|
_InlineMetaPill(icon: Icons.sell_outlined, label: tag),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 10),
|
|
_PeopleInsightBodyBlock(
|
|
text: hasNotes
|
|
? person.notes.trim()
|
|
: 'Add notes about preferences, boundaries, and what matters so future follow-ups stay relevant.',
|
|
muted: !hasNotes,
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleInsightSectionCard(
|
|
title: 'Ideas',
|
|
icon: Icons.lightbulb_outline_rounded,
|
|
children: ideas.isEmpty
|
|
? const <Widget>[
|
|
_PeopleSectionEmpty(
|
|
label:
|
|
'No ideas yet. Use Quick add to capture gift or event ideas.',
|
|
),
|
|
]
|
|
: ideas
|
|
.take(compact ? 4 : 6)
|
|
.map(
|
|
(RelationshipIdea idea) => _PeopleInsightRow(
|
|
title: idea.title,
|
|
subtitle: idea.details.isEmpty
|
|
? 'No details yet'
|
|
: idea.details,
|
|
meta:
|
|
'${idea.type.name.toUpperCase()} • ${_shortDateTimeLabel(idea.createdAt)}${idea.isArchived ? ' • ARCHIVED' : ''}',
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleInsightSectionCard(
|
|
title: 'Moments',
|
|
icon: Icons.auto_awesome_rounded,
|
|
children: moments.isEmpty
|
|
? const <Widget>[
|
|
_PeopleSectionEmpty(
|
|
label: 'No captures logged yet for this person.',
|
|
),
|
|
]
|
|
: moments
|
|
.take(compact ? 4 : 6)
|
|
.map(
|
|
(RelationshipMoment moment) => _PeopleInsightRow(
|
|
title: moment.title,
|
|
subtitle: moment.summary,
|
|
meta:
|
|
'${moment.type.toUpperCase()} • ${_shortDateTimeLabel(moment.at)}',
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleInsightSectionCard(
|
|
title: 'Reminders',
|
|
icon: Icons.notifications_active_outlined,
|
|
children: reminders.isEmpty
|
|
? const <Widget>[
|
|
_PeopleSectionEmpty(
|
|
label:
|
|
'No reminders yet. Add one to keep the relationship active.',
|
|
),
|
|
]
|
|
: reminders
|
|
.take(compact ? 4 : 6)
|
|
.map(
|
|
(ReminderRule reminder) => _PeopleInsightRow(
|
|
title: reminder.title,
|
|
subtitle: reminder.enabled ? 'Enabled' : 'Disabled',
|
|
meta:
|
|
'${reminder.cadence.name.toUpperCase()} • Next ${_shortDateTimeLabel(reminder.nextAt)}',
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
),
|
|
const SizedBox(height: 12),
|
|
_PeopleInsightSectionCard(
|
|
title: 'Shared message history',
|
|
icon: Icons.chat_bubble_outline_rounded,
|
|
children: sharedMessages.isEmpty
|
|
? const <Widget>[
|
|
_PeopleSectionEmpty(
|
|
label: 'No imported shared messages for this profile yet.',
|
|
),
|
|
]
|
|
: sharedMessages
|
|
.take(compact ? 3 : 5)
|
|
.map(
|
|
(SharedMessageEntry entry) => _PeopleInsightRow(
|
|
title:
|
|
entry.sourceDisplayName?.trim().isNotEmpty == true
|
|
? entry.sourceDisplayName!.trim()
|
|
: 'Shared from ${entry.sourceApp}',
|
|
subtitle: entry.messageText.trim().isEmpty
|
|
? 'Imported message content is empty'
|
|
: entry.messageText.trim(),
|
|
meta:
|
|
'${entry.resolvedAutomatically ? 'AUTO-LINKED' : 'MANUAL-LINK'} • ${_shortDateTimeLabel(entry.sharedAt)}',
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonWorkspaceHero extends StatelessWidget {
|
|
const _PersonWorkspaceHero({
|
|
required this.person,
|
|
required this.compact,
|
|
required this.sourceLinks,
|
|
required this.onEdit,
|
|
required this.onDelete,
|
|
required this.onQuickAction,
|
|
});
|
|
|
|
final PersonProfile person;
|
|
final bool compact;
|
|
final List<SourceProfileLink> sourceLinks;
|
|
final VoidCallback onEdit;
|
|
final VoidCallback onDelete;
|
|
final ValueChanged<_PersonQuickAction> onQuickAction;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final Widget actions = Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
alignment: WrapAlignment.end,
|
|
children: <Widget>[
|
|
FilledButton.icon(
|
|
onPressed: () => onQuickAction(_PersonQuickAction.capture),
|
|
icon: const Icon(Icons.add_comment_outlined, size: 18),
|
|
label: const Text('Capture'),
|
|
),
|
|
OutlinedButton.icon(
|
|
onPressed: () => onQuickAction(_PersonQuickAction.idea),
|
|
icon: const Icon(Icons.lightbulb_outline_rounded, size: 18),
|
|
label: const Text('Idea'),
|
|
),
|
|
PopupMenuButton<_PersonQuickAction>(
|
|
tooltip: 'More quick add actions',
|
|
onSelected: onQuickAction,
|
|
itemBuilder: (BuildContext context) =>
|
|
const <PopupMenuEntry<_PersonQuickAction>>[
|
|
PopupMenuItem<_PersonQuickAction>(
|
|
value: _PersonQuickAction.capture,
|
|
child: Text('Add Capture'),
|
|
),
|
|
PopupMenuItem<_PersonQuickAction>(
|
|
value: _PersonQuickAction.note,
|
|
child: Text('Add Note'),
|
|
),
|
|
PopupMenuItem<_PersonQuickAction>(
|
|
value: _PersonQuickAction.idea,
|
|
child: Text('Add Idea'),
|
|
),
|
|
PopupMenuItem<_PersonQuickAction>(
|
|
value: _PersonQuickAction.reminder,
|
|
child: Text('Add Reminder'),
|
|
),
|
|
],
|
|
child: const _HeroIconButton(
|
|
icon: Icons.add_circle_outline_rounded,
|
|
tooltip: 'Quick add',
|
|
),
|
|
),
|
|
IconButton(
|
|
onPressed: onEdit,
|
|
icon: const Icon(Icons.edit_rounded),
|
|
tooltip: 'Edit person',
|
|
),
|
|
IconButton(
|
|
onPressed: onDelete,
|
|
icon: const Icon(Icons.delete_outline_rounded),
|
|
tooltip: 'Delete person',
|
|
),
|
|
],
|
|
);
|
|
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: EdgeInsets.all(compact ? 14 : 16),
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.circular(18),
|
|
gradient: const LinearGradient(
|
|
begin: Alignment.topLeft,
|
|
end: Alignment.bottomRight,
|
|
colors: <Color>[Color(0xFFF7FBFD), Color(0xFFEAF4FA)],
|
|
),
|
|
border: Border.all(color: Colors.white.withValues(alpha: 0.9)),
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
if (compact) ...<Widget>[
|
|
Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
_AvatarSeed(name: person.name, size: 58),
|
|
const SizedBox(width: 12),
|
|
Expanded(child: _HeroIdentity(person: person)),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
actions,
|
|
] else ...<Widget>[
|
|
Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
_AvatarSeed(name: person.name, size: 64),
|
|
const SizedBox(width: 14),
|
|
Expanded(child: _HeroIdentity(person: person)),
|
|
const SizedBox(width: 10),
|
|
Flexible(
|
|
child: Align(alignment: Alignment.topRight, child: actions),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
const SizedBox(height: 10),
|
|
Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
children: <Widget>[
|
|
_InlineMetaPill(
|
|
icon: Icons.schedule_rounded,
|
|
label: 'Next ${_dateTimeLabel(person.nextMoment)}',
|
|
),
|
|
if (sourceLinks.isNotEmpty)
|
|
_InlineMetaPill(
|
|
icon: Icons.link_rounded,
|
|
label:
|
|
'Last linked ${_shortDateTimeLabel(sourceLinks.first.lastSeenAt)}',
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _HeroIdentity extends StatelessWidget {
|
|
const _HeroIdentity({required this.person});
|
|
|
|
final PersonProfile person;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text(
|
|
person.name,
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
person.relationship,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyLarge?.copyWith(color: AppTheme.textSecondary),
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _HeroIconButton extends StatelessWidget {
|
|
const _HeroIconButton({required this.icon, required this.tooltip});
|
|
|
|
final IconData icon;
|
|
final String tooltip;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Tooltip(
|
|
message: tooltip,
|
|
child: Container(
|
|
width: 40,
|
|
height: 40,
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFF2F7FA),
|
|
borderRadius: BorderRadius.circular(12),
|
|
border: Border.all(color: Colors.white),
|
|
),
|
|
child: Icon(icon, color: AppTheme.primary, size: 20),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonStatTile extends StatelessWidget {
|
|
const _PersonStatTile({
|
|
required this.label,
|
|
required this.value,
|
|
required this.accent,
|
|
required this.compact,
|
|
});
|
|
|
|
final String label;
|
|
final String value;
|
|
final Color accent;
|
|
final bool compact;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final double width = compact ? 154 : 172;
|
|
return Container(
|
|
width: width,
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white.withValues(alpha: 0.66),
|
|
borderRadius: BorderRadius.circular(14),
|
|
border: Border.all(color: accent.withValues(alpha: 0.12)),
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text(
|
|
label,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.labelMedium?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
value,
|
|
maxLines: 2,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: Theme.of(context).textTheme.titleMedium?.copyWith(
|
|
color: accent,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleInsightSectionCard extends StatelessWidget {
|
|
const _PeopleInsightSectionCard({
|
|
required this.title,
|
|
required this.icon,
|
|
required this.children,
|
|
});
|
|
|
|
final String title;
|
|
final IconData icon;
|
|
final List<Widget> children;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFF8FBFD),
|
|
borderRadius: BorderRadius.circular(16),
|
|
border: Border.all(color: Colors.white.withValues(alpha: 0.9)),
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Row(
|
|
children: <Widget>[
|
|
Icon(icon, size: 18, color: AppTheme.primary),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: Text(
|
|
title,
|
|
style: Theme.of(context).textTheme.titleMedium,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 10),
|
|
...children,
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleInsightRow extends StatelessWidget {
|
|
const _PeopleInsightRow({
|
|
required this.title,
|
|
required this.subtitle,
|
|
required this.meta,
|
|
});
|
|
|
|
final String title;
|
|
final String subtitle;
|
|
final String meta;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.only(bottom: 10),
|
|
child: Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
borderRadius: BorderRadius.circular(12),
|
|
border: Border.all(color: const Color(0xFFEAF1F4)),
|
|
),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text(
|
|
title,
|
|
style: Theme.of(context).textTheme.titleSmall,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
subtitle,
|
|
maxLines: 3,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyMedium?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
meta,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.labelSmall?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleInsightBodyBlock extends StatelessWidget {
|
|
const _PeopleInsightBodyBlock({required this.text, required this.muted});
|
|
|
|
final String text;
|
|
final bool muted;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
borderRadius: BorderRadius.circular(12),
|
|
border: Border.all(color: const Color(0xFFEAF1F4)),
|
|
),
|
|
child: Text(
|
|
text,
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
color: muted ? AppTheme.textSecondary : null,
|
|
height: 1.35,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleSectionEmpty extends StatelessWidget {
|
|
const _PeopleSectionEmpty({required this.label});
|
|
|
|
final String label;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
width: double.infinity,
|
|
padding: const EdgeInsets.all(12),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
borderRadius: BorderRadius.circular(12),
|
|
border: Border.all(color: const Color(0xFFEAF1F4)),
|
|
),
|
|
child: Text(
|
|
label,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyMedium?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PeopleHeader extends StatelessWidget {
|
|
const _PeopleHeader({
|
|
required this.onAdd,
|
|
required this.onMerge,
|
|
required this.compact,
|
|
});
|
|
|
|
final VoidCallback onAdd;
|
|
final VoidCallback onMerge;
|
|
final bool compact;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final TextTheme textTheme = Theme.of(context).textTheme;
|
|
if (compact) {
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text('People', style: textTheme.headlineMedium),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
'Track what matters to each relationship and follow through.',
|
|
style: textTheme.bodyLarge?.copyWith(color: AppTheme.textSecondary),
|
|
maxLines: 2,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
const SizedBox(height: 12),
|
|
FilledButton.icon(
|
|
onPressed: onAdd,
|
|
icon: const Icon(Icons.person_add_alt_1_rounded),
|
|
label: const Text('Add person'),
|
|
),
|
|
const SizedBox(height: 8),
|
|
OutlinedButton.icon(
|
|
onPressed: onMerge,
|
|
icon: const Icon(Icons.merge_type_rounded),
|
|
label: const Text('Merge duplicates'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
return Row(
|
|
children: <Widget>[
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text('People', style: textTheme.headlineMedium),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
'Track what matters to each relationship and follow through.',
|
|
style: textTheme.bodyLarge?.copyWith(
|
|
color: AppTheme.textSecondary,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
FilledButton.icon(
|
|
onPressed: onAdd,
|
|
icon: const Icon(Icons.person_add_alt_1_rounded),
|
|
label: const Text('Add'),
|
|
),
|
|
const SizedBox(width: 8),
|
|
OutlinedButton.icon(
|
|
onPressed: onMerge,
|
|
icon: const Icon(Icons.merge_type_rounded),
|
|
label: const Text('Merge'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonListItem extends StatelessWidget {
|
|
const _PersonListItem({
|
|
required this.person,
|
|
required this.selectedId,
|
|
required this.compact,
|
|
required this.onSelect,
|
|
});
|
|
|
|
final PersonProfile person;
|
|
final String selectedId;
|
|
final bool compact;
|
|
final VoidCallback onSelect;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final bool isSelected = person.id == selectedId;
|
|
return InkWell(
|
|
onTap: onSelect,
|
|
borderRadius: BorderRadius.circular(20),
|
|
child: FrostedCard(
|
|
padding: const EdgeInsets.all(16),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Row(
|
|
children: <Widget>[
|
|
_AvatarSeed(name: person.name),
|
|
const SizedBox(width: 14),
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Text(
|
|
person.name,
|
|
style: Theme.of(context).textTheme.titleMedium,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
person.relationship,
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
color: AppTheme.textSecondary,
|
|
),
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
_ScorePill(score: person.affinityScore),
|
|
if (isSelected)
|
|
const Padding(
|
|
padding: EdgeInsets.only(left: 10),
|
|
child: Icon(Icons.check_circle, color: Color(0xFF1AB6C8)),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 10),
|
|
Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
children: <Widget>[
|
|
_InlineMetaPill(
|
|
icon: Icons.schedule_rounded,
|
|
label: _dateTimeLabel(person.nextMoment),
|
|
),
|
|
if ((person.location ?? '').trim().isNotEmpty)
|
|
_InlineMetaPill(
|
|
icon: Icons.location_on_outlined,
|
|
label: person.location!.trim(),
|
|
),
|
|
...person.tags
|
|
.take(compact ? 2 : 3)
|
|
.map(
|
|
(String tag) => _InlineMetaPill(
|
|
icon: Icons.sell_outlined,
|
|
label: tag,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonEditorDialog extends StatefulWidget {
|
|
const _PersonEditorDialog({required this.title, this.initial});
|
|
|
|
final String title;
|
|
final _PersonDraft? initial;
|
|
|
|
@override
|
|
State<_PersonEditorDialog> createState() => _PersonEditorDialogState();
|
|
}
|
|
|
|
class _PersonEditorDialogState extends State<_PersonEditorDialog> {
|
|
late final TextEditingController _nameController;
|
|
late final TextEditingController _relationshipController;
|
|
late final TextEditingController _locationController;
|
|
late final TextEditingController _tagsController;
|
|
late final TextEditingController _notesController;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_nameController = TextEditingController(text: widget.initial?.name ?? '');
|
|
_relationshipController = TextEditingController(
|
|
text: widget.initial?.relationship ?? '',
|
|
);
|
|
_locationController = TextEditingController(
|
|
text: widget.initial?.location ?? '',
|
|
);
|
|
_tagsController = TextEditingController(
|
|
text: widget.initial?.tags.join(', ') ?? '',
|
|
);
|
|
_notesController = TextEditingController(text: widget.initial?.notes ?? '');
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_nameController.dispose();
|
|
_relationshipController.dispose();
|
|
_locationController.dispose();
|
|
_tagsController.dispose();
|
|
_notesController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(widget.title),
|
|
content: SingleChildScrollView(
|
|
child: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: 420),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
TextField(
|
|
controller: _nameController,
|
|
decoration: const InputDecoration(labelText: 'Name'),
|
|
),
|
|
TextField(
|
|
controller: _relationshipController,
|
|
decoration: const InputDecoration(labelText: 'Relationship'),
|
|
),
|
|
TextField(
|
|
controller: _locationController,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Location (optional)',
|
|
),
|
|
),
|
|
TextField(
|
|
controller: _tagsController,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Tags (comma separated)',
|
|
),
|
|
),
|
|
TextField(
|
|
controller: _notesController,
|
|
maxLines: 3,
|
|
decoration: const InputDecoration(labelText: 'Notes'),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () {
|
|
final String name = _nameController.text.trim();
|
|
final String relationship = _relationshipController.text.trim();
|
|
if (name.isEmpty || relationship.isEmpty) {
|
|
return;
|
|
}
|
|
|
|
final _PersonDraft draft = _PersonDraft(
|
|
name: name,
|
|
relationship: relationship,
|
|
location: _locationController.text.trim().isEmpty
|
|
? null
|
|
: _locationController.text.trim(),
|
|
notes: _notesController.text.trim(),
|
|
tags: _tagsController.text
|
|
.split(',')
|
|
.map((String tag) => tag.trim())
|
|
.where((String tag) => tag.isNotEmpty)
|
|
.toList(growable: false),
|
|
);
|
|
Navigator.of(context).pop(draft);
|
|
},
|
|
child: const Text('Save'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PersonDraft {
|
|
const _PersonDraft({
|
|
required this.name,
|
|
required this.relationship,
|
|
required this.notes,
|
|
required this.tags,
|
|
this.location,
|
|
});
|
|
|
|
final String name;
|
|
final String relationship;
|
|
final String notes;
|
|
final List<String> tags;
|
|
final String? location;
|
|
}
|
|
|
|
class _MergePeopleDraft {
|
|
const _MergePeopleDraft({
|
|
required this.sourcePersonId,
|
|
required this.targetPersonId,
|
|
});
|
|
|
|
final String sourcePersonId;
|
|
final String targetPersonId;
|
|
}
|
|
|
|
class _MergePeopleDialog extends StatefulWidget {
|
|
const _MergePeopleDialog({required this.people});
|
|
|
|
final List<PersonProfile> people;
|
|
|
|
@override
|
|
State<_MergePeopleDialog> createState() => _MergePeopleDialogState();
|
|
}
|
|
|
|
class _MergePeopleDialogState extends State<_MergePeopleDialog> {
|
|
late String _sourcePersonId;
|
|
late String _targetPersonId;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_targetPersonId = widget.people.first.id;
|
|
_sourcePersonId = widget.people.length > 1
|
|
? widget.people[1].id
|
|
: widget.people.first.id;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: const Text('Merge Duplicate Profiles'),
|
|
content: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: 420),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
Text(
|
|
'Move captures, ideas, reminders, and share links from source into target profile.',
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.bodyMedium?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
const SizedBox(height: 12),
|
|
DropdownButtonFormField<String>(
|
|
key: ValueKey<String>('target-$_targetPersonId'),
|
|
initialValue: _targetPersonId,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Keep target profile',
|
|
),
|
|
items: widget.people
|
|
.map(
|
|
(PersonProfile person) => DropdownMenuItem<String>(
|
|
value: person.id,
|
|
child: Text('${person.name} · ${person.relationship}'),
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
onChanged: (String? value) {
|
|
if (value == null) {
|
|
return;
|
|
}
|
|
setState(() {
|
|
_targetPersonId = value;
|
|
if (_targetPersonId == _sourcePersonId) {
|
|
_sourcePersonId = widget.people
|
|
.firstWhere(
|
|
(PersonProfile person) =>
|
|
person.id != _targetPersonId,
|
|
orElse: () => widget.people.first,
|
|
)
|
|
.id;
|
|
}
|
|
});
|
|
},
|
|
),
|
|
const SizedBox(height: 10),
|
|
DropdownButtonFormField<String>(
|
|
key: ValueKey<String>('source-$_targetPersonId-$_sourcePersonId'),
|
|
initialValue: _sourcePersonId,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Merge and remove source profile',
|
|
),
|
|
items: widget.people
|
|
.where((PersonProfile person) => person.id != _targetPersonId)
|
|
.map(
|
|
(PersonProfile person) => DropdownMenuItem<String>(
|
|
value: person.id,
|
|
child: Text('${person.name} · ${person.relationship}'),
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
onChanged: (String? value) {
|
|
if (value == null) {
|
|
return;
|
|
}
|
|
setState(() {
|
|
_sourcePersonId = value;
|
|
});
|
|
},
|
|
),
|
|
],
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () {
|
|
if (_sourcePersonId == _targetPersonId) {
|
|
return;
|
|
}
|
|
Navigator.of(context).pop(
|
|
_MergePeopleDraft(
|
|
sourcePersonId: _sourcePersonId,
|
|
targetPersonId: _targetPersonId,
|
|
),
|
|
);
|
|
},
|
|
child: const Text('Merge'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _QuickIdeaDraft {
|
|
const _QuickIdeaDraft({
|
|
required this.type,
|
|
required this.title,
|
|
required this.details,
|
|
});
|
|
|
|
final IdeaType type;
|
|
final String title;
|
|
final String details;
|
|
}
|
|
|
|
class _QuickIdeaDialog extends StatefulWidget {
|
|
const _QuickIdeaDialog();
|
|
|
|
@override
|
|
State<_QuickIdeaDialog> createState() => _QuickIdeaDialogState();
|
|
}
|
|
|
|
class _QuickIdeaDialogState extends State<_QuickIdeaDialog> {
|
|
IdeaType _type = IdeaType.gift;
|
|
final TextEditingController _titleController = TextEditingController();
|
|
final TextEditingController _detailsController = TextEditingController();
|
|
|
|
@override
|
|
void dispose() {
|
|
_titleController.dispose();
|
|
_detailsController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: const Text('Add Idea'),
|
|
content: SingleChildScrollView(
|
|
child: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: 420),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
SegmentedButton<IdeaType>(
|
|
segments: const <ButtonSegment<IdeaType>>[
|
|
ButtonSegment<IdeaType>(
|
|
value: IdeaType.gift,
|
|
label: Text('Gift'),
|
|
),
|
|
ButtonSegment<IdeaType>(
|
|
value: IdeaType.event,
|
|
label: Text('Event'),
|
|
),
|
|
],
|
|
selected: <IdeaType>{_type},
|
|
onSelectionChanged: (Set<IdeaType> values) {
|
|
setState(() {
|
|
_type = values.first;
|
|
});
|
|
},
|
|
),
|
|
const SizedBox(height: 10),
|
|
TextField(
|
|
controller: _titleController,
|
|
decoration: const InputDecoration(labelText: 'Title'),
|
|
),
|
|
TextField(
|
|
controller: _detailsController,
|
|
maxLines: 3,
|
|
decoration: const InputDecoration(labelText: 'Details'),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () {
|
|
final String title = _titleController.text.trim();
|
|
if (title.isEmpty) {
|
|
return;
|
|
}
|
|
Navigator.of(context).pop(
|
|
_QuickIdeaDraft(
|
|
type: _type,
|
|
title: title,
|
|
details: _detailsController.text.trim(),
|
|
),
|
|
);
|
|
},
|
|
child: const Text('Add'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _QuickReminderDraft {
|
|
const _QuickReminderDraft({
|
|
required this.title,
|
|
required this.cadence,
|
|
required this.nextAt,
|
|
});
|
|
|
|
final String title;
|
|
final ReminderCadence cadence;
|
|
final DateTime nextAt;
|
|
}
|
|
|
|
class _QuickReminderDialog extends StatefulWidget {
|
|
const _QuickReminderDialog();
|
|
|
|
@override
|
|
State<_QuickReminderDialog> createState() => _QuickReminderDialogState();
|
|
}
|
|
|
|
class _QuickReminderDialogState extends State<_QuickReminderDialog> {
|
|
final TextEditingController _titleController = TextEditingController();
|
|
ReminderCadence _cadence = ReminderCadence.weekly;
|
|
DateTime _nextAt = DateTime.now().add(const Duration(days: 1));
|
|
|
|
@override
|
|
void dispose() {
|
|
_titleController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: const Text('Add Reminder'),
|
|
content: SingleChildScrollView(
|
|
child: ConstrainedBox(
|
|
constraints: const BoxConstraints(maxWidth: 420),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
TextField(
|
|
controller: _titleController,
|
|
decoration: const InputDecoration(labelText: 'Title'),
|
|
),
|
|
const SizedBox(height: 10),
|
|
DropdownButtonFormField<ReminderCadence>(
|
|
initialValue: _cadence,
|
|
decoration: const InputDecoration(labelText: 'Cadence'),
|
|
items: ReminderCadence.values
|
|
.map(
|
|
(ReminderCadence cadence) =>
|
|
DropdownMenuItem<ReminderCadence>(
|
|
value: cadence,
|
|
child: Text(cadence.name),
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
onChanged: (ReminderCadence? value) {
|
|
if (value == null) {
|
|
return;
|
|
}
|
|
setState(() {
|
|
_cadence = value;
|
|
});
|
|
},
|
|
),
|
|
const SizedBox(height: 10),
|
|
Row(
|
|
children: <Widget>[
|
|
Expanded(
|
|
child: Text(
|
|
'Next: ${_nextAt.year}-${_nextAt.month.toString().padLeft(2, '0')}-${_nextAt.day.toString().padLeft(2, '0')} ${_nextAt.hour.toString().padLeft(2, '0')}:${_nextAt.minute.toString().padLeft(2, '0')}',
|
|
),
|
|
),
|
|
TextButton(
|
|
onPressed: () async {
|
|
final DateTime now = DateTime.now();
|
|
final DateTime? date = await showDatePicker(
|
|
context: context,
|
|
firstDate: now,
|
|
lastDate: now.add(const Duration(days: 3650)),
|
|
initialDate: _nextAt,
|
|
);
|
|
if (date == null || !context.mounted) {
|
|
return;
|
|
}
|
|
final TimeOfDay? time = await showTimePicker(
|
|
context: context,
|
|
initialTime: TimeOfDay.fromDateTime(_nextAt),
|
|
);
|
|
if (time == null) {
|
|
return;
|
|
}
|
|
setState(() {
|
|
_nextAt = DateTime(
|
|
date.year,
|
|
date.month,
|
|
date.day,
|
|
time.hour,
|
|
time.minute,
|
|
);
|
|
});
|
|
},
|
|
child: const Text('Change'),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
actions: <Widget>[
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () {
|
|
final String title = _titleController.text.trim();
|
|
if (title.isEmpty) {
|
|
return;
|
|
}
|
|
Navigator.of(context).pop(
|
|
_QuickReminderDraft(
|
|
title: title,
|
|
cadence: _cadence,
|
|
nextAt: _nextAt,
|
|
),
|
|
);
|
|
},
|
|
child: const Text('Add'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class _InlineMetaPill extends StatelessWidget {
|
|
const _InlineMetaPill({required this.icon, required this.label});
|
|
|
|
final IconData icon;
|
|
final String label;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 7),
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFF1F7FA),
|
|
borderRadius: BorderRadius.circular(99),
|
|
border: Border.all(color: Colors.white),
|
|
),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: <Widget>[
|
|
Icon(icon, size: 14, color: AppTheme.textSecondary),
|
|
const SizedBox(width: 6),
|
|
Flexible(
|
|
child: Text(
|
|
label,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: Theme.of(
|
|
context,
|
|
).textTheme.labelLarge?.copyWith(color: AppTheme.textSecondary),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _AvatarSeed extends StatelessWidget {
|
|
const _AvatarSeed({required this.name, this.size = 48});
|
|
|
|
final String name;
|
|
final double size;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final String initials = name
|
|
.split(' ')
|
|
.where((String part) => part.isNotEmpty)
|
|
.take(2)
|
|
.map((String part) => part[0].toUpperCase())
|
|
.join();
|
|
|
|
return Container(
|
|
width: size,
|
|
height: size,
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.circular(size / 2),
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF1AB6C8), Color(0xFF2274E0)],
|
|
),
|
|
),
|
|
alignment: Alignment.center,
|
|
child: Text(
|
|
initials,
|
|
style: Theme.of(context).textTheme.titleMedium?.copyWith(
|
|
color: Colors.white,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _ScorePill extends StatelessWidget {
|
|
const _ScorePill({required this.score});
|
|
|
|
final int score;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
|
|
decoration: BoxDecoration(
|
|
color: const Color(0xFFEEF7F3),
|
|
borderRadius: BorderRadius.circular(99),
|
|
),
|
|
child: Text(
|
|
'$score%',
|
|
style: Theme.of(context).textTheme.labelLarge?.copyWith(
|
|
color: const Color(0xFF1D9C66),
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _dateTimeLabel(DateTime value) {
|
|
final DateTime local = value.toLocal();
|
|
final String month = local.month.toString().padLeft(2, '0');
|
|
final String day = local.day.toString().padLeft(2, '0');
|
|
final String hour = local.hour.toString().padLeft(2, '0');
|
|
final String minute = local.minute.toString().padLeft(2, '0');
|
|
return '$month/$day $hour:$minute';
|
|
}
|
|
|
|
String _shortDateTimeLabel(DateTime value) {
|
|
final DateTime local = value.toLocal();
|
|
final String year = local.year.toString();
|
|
final String month = local.month.toString().padLeft(2, '0');
|
|
final String day = local.day.toString().padLeft(2, '0');
|
|
final String hour = local.hour.toString().padLeft(2, '0');
|
|
final String minute = local.minute.toString().padLeft(2, '0');
|
|
return '$year-$month-$day $hour:$minute';
|
|
}
|