391 lines
12 KiB
Dart
391 lines
12 KiB
Dart
import 'package:get/get.dart';
|
|
import 'package:marco/helpers/services/api_service.dart';
|
|
import 'package:marco/helpers/services/app_logger.dart';
|
|
import 'package:marco/helpers/widgets/my_snackbar.dart';
|
|
import 'package:marco/model/directory/contact_model.dart';
|
|
import 'package:marco/model/directory/contact_bucket_list_model.dart';
|
|
import 'package:marco/model/directory/directory_comment_model.dart';
|
|
|
|
class DirectoryController extends GetxController {
|
|
// -------------------- CONTACTS --------------------
|
|
RxList<ContactModel> allContacts = <ContactModel>[].obs;
|
|
RxList<ContactModel> filteredContacts = <ContactModel>[].obs;
|
|
RxList<ContactCategory> contactCategories = <ContactCategory>[].obs;
|
|
RxList<String> selectedCategories = <String>[].obs;
|
|
RxList<String> selectedBuckets = <String>[].obs;
|
|
RxBool isActive = true.obs;
|
|
RxBool isLoading = false.obs;
|
|
RxList<ContactBucket> contactBuckets = <ContactBucket>[].obs;
|
|
RxString searchQuery = ''.obs;
|
|
|
|
// -------------------- COMMENTS --------------------
|
|
final Map<String, RxList<DirectoryComment>> activeCommentsMap = {};
|
|
final Map<String, RxList<DirectoryComment>> inactiveCommentsMap = {};
|
|
final editingCommentId = Rxn<String>();
|
|
|
|
@override
|
|
void onInit() {
|
|
super.onInit();
|
|
fetchContacts();
|
|
fetchBuckets();
|
|
}
|
|
|
|
// -------------------- COMMENTS HANDLING --------------------
|
|
|
|
RxList<DirectoryComment> getCommentsForContact(String contactId,
|
|
{bool active = true}) {
|
|
return active
|
|
? activeCommentsMap[contactId] ?? <DirectoryComment>[].obs
|
|
: inactiveCommentsMap[contactId] ?? <DirectoryComment>[].obs;
|
|
}
|
|
|
|
Future<void> fetchCommentsForContact(String contactId,
|
|
{bool active = true}) async {
|
|
try {
|
|
final data =
|
|
await ApiService.getDirectoryComments(contactId, active: active);
|
|
var comments =
|
|
data?.map((e) => DirectoryComment.fromJson(e)).toList() ?? [];
|
|
|
|
// ✅ Deduplicate by ID before storing
|
|
final Map<String, DirectoryComment> uniqueMap = {
|
|
for (var c in comments) c.id: c,
|
|
};
|
|
comments = uniqueMap.values.toList()
|
|
..sort((a, b) => b.createdAt.compareTo(a.createdAt));
|
|
|
|
if (active) {
|
|
activeCommentsMap[contactId] = <DirectoryComment>[].obs
|
|
..assignAll(comments);
|
|
} else {
|
|
inactiveCommentsMap[contactId] = <DirectoryComment>[].obs
|
|
..assignAll(comments);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Error fetching ${active ? 'active' : 'inactive'} comments: $e",
|
|
level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
|
|
if (active) {
|
|
activeCommentsMap[contactId] = <DirectoryComment>[].obs;
|
|
} else {
|
|
inactiveCommentsMap[contactId] = <DirectoryComment>[].obs;
|
|
}
|
|
}
|
|
}
|
|
|
|
List<DirectoryComment> combinedComments(String contactId) {
|
|
final activeList = getCommentsForContact(contactId, active: true);
|
|
final inactiveList = getCommentsForContact(contactId, active: false);
|
|
|
|
// ✅ Deduplicate by ID (active wins)
|
|
final Map<String, DirectoryComment> byId = {};
|
|
for (final c in inactiveList) {
|
|
byId[c.id] = c;
|
|
}
|
|
for (final c in activeList) {
|
|
byId[c.id] = c;
|
|
}
|
|
|
|
final combined = byId.values.toList()
|
|
..sort((a, b) => b.createdAt.compareTo(a.createdAt));
|
|
return combined;
|
|
}
|
|
|
|
Future<void> updateComment(DirectoryComment comment) async {
|
|
try {
|
|
final existing = getCommentsForContact(comment.contactId)
|
|
.firstWhereOrNull((c) => c.id == comment.id);
|
|
|
|
if (existing != null && existing.note.trim() == comment.note.trim()) {
|
|
showAppSnackbar(
|
|
title: "No Changes",
|
|
message: "No changes were made to the comment.",
|
|
type: SnackbarType.info,
|
|
);
|
|
return;
|
|
}
|
|
|
|
final success = await ApiService.updateContactComment(
|
|
comment.id, comment.note, comment.contactId);
|
|
|
|
if (success) {
|
|
await fetchCommentsForContact(comment.contactId, active: true);
|
|
await fetchCommentsForContact(comment.contactId, active: false);
|
|
showAppSnackbar(
|
|
title: "Success",
|
|
message: "Comment updated successfully.",
|
|
type: SnackbarType.success,
|
|
);
|
|
} else {
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to update comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Update comment failed: $e", level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to update comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> deleteComment(String commentId, String contactId) async {
|
|
try {
|
|
final success = await ApiService.restoreContactComment(commentId, false);
|
|
|
|
if (success) {
|
|
if (editingCommentId.value == commentId) editingCommentId.value = null;
|
|
await fetchCommentsForContact(contactId, active: true);
|
|
await fetchCommentsForContact(contactId, active: false);
|
|
showAppSnackbar(
|
|
title: "Deleted",
|
|
message: "Comment deleted successfully.",
|
|
type: SnackbarType.success,
|
|
);
|
|
} else {
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to delete comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Delete comment failed: $e", level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Something went wrong while deleting comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> restoreComment(String commentId, String contactId) async {
|
|
try {
|
|
final success = await ApiService.restoreContactComment(commentId, true);
|
|
|
|
if (success) {
|
|
await fetchCommentsForContact(contactId, active: true);
|
|
await fetchCommentsForContact(contactId, active: false);
|
|
showAppSnackbar(
|
|
title: "Restored",
|
|
message: "Comment restored successfully.",
|
|
type: SnackbarType.success,
|
|
);
|
|
} else {
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to restore comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Restore comment failed: $e", level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Something went wrong while restoring comment.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
}
|
|
|
|
// -------------------- CONTACTS HANDLING --------------------
|
|
|
|
Future<void> fetchBuckets() async {
|
|
try {
|
|
final response = await ApiService.getContactBucketList();
|
|
if (response != null && response['data'] is List) {
|
|
final buckets = (response['data'] as List)
|
|
.map((e) => ContactBucket.fromJson(e))
|
|
.toList();
|
|
contactBuckets.assignAll(buckets);
|
|
} else {
|
|
contactBuckets.clear();
|
|
}
|
|
} catch (e) {
|
|
logSafe("Bucket fetch error: $e", level: LogLevel.error);
|
|
}
|
|
}
|
|
// -------------------- CONTACT DELETION / RESTORE --------------------
|
|
|
|
Future<void> deleteContact(String contactId) async {
|
|
try {
|
|
final success = await ApiService.deleteDirectoryContact(contactId);
|
|
if (success) {
|
|
// Refresh contacts after deletion
|
|
await fetchContacts(active: true);
|
|
await fetchContacts(active: false);
|
|
showAppSnackbar(
|
|
title: "Deleted",
|
|
message: "Contact deleted successfully.",
|
|
type: SnackbarType.success,
|
|
);
|
|
} else {
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to delete contact.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Delete contact failed: $e", level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Something went wrong while deleting contact.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> restoreContact(String contactId) async {
|
|
try {
|
|
final success = await ApiService.restoreDirectoryContact(contactId);
|
|
if (success) {
|
|
// Refresh contacts after restore
|
|
await fetchContacts(active: true);
|
|
await fetchContacts(active: false);
|
|
showAppSnackbar(
|
|
title: "Restored",
|
|
message: "Contact restored successfully.",
|
|
type: SnackbarType.success,
|
|
);
|
|
} else {
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Failed to restore contact.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
} catch (e, stack) {
|
|
logSafe("Restore contact failed: $e", level: LogLevel.error);
|
|
logSafe(stack.toString(), level: LogLevel.debug);
|
|
showAppSnackbar(
|
|
title: "Error",
|
|
message: "Something went wrong while restoring contact.",
|
|
type: SnackbarType.error,
|
|
);
|
|
}
|
|
}
|
|
|
|
Future<void> fetchContacts({bool active = true}) async {
|
|
try {
|
|
isLoading.value = true;
|
|
final response = await ApiService.getDirectoryData(isActive: active);
|
|
|
|
if (response != null) {
|
|
final contacts = response.map((e) => ContactModel.fromJson(e)).toList();
|
|
allContacts.assignAll(contacts);
|
|
extractCategoriesFromContacts();
|
|
applyFilters();
|
|
} else {
|
|
allContacts.clear();
|
|
filteredContacts.clear();
|
|
}
|
|
} catch (e) {
|
|
logSafe("Directory fetch error: $e", level: LogLevel.error);
|
|
} finally {
|
|
isLoading.value = false;
|
|
}
|
|
}
|
|
|
|
void extractCategoriesFromContacts() {
|
|
final uniqueCategories = <String, ContactCategory>{};
|
|
for (final contact in allContacts) {
|
|
final category = contact.contactCategory;
|
|
if (category != null) {
|
|
uniqueCategories.putIfAbsent(category.id, () => category);
|
|
}
|
|
}
|
|
contactCategories.value = uniqueCategories.values.toList();
|
|
}
|
|
|
|
void applyFilters() {
|
|
final query = searchQuery.value.toLowerCase();
|
|
|
|
filteredContacts.value = allContacts.where((contact) {
|
|
final categoryMatch = selectedCategories.isEmpty ||
|
|
(contact.contactCategory != null &&
|
|
selectedCategories.contains(contact.contactCategory!.id));
|
|
|
|
final bucketMatch = selectedBuckets.isEmpty ||
|
|
contact.bucketIds.any((id) => selectedBuckets.contains(id));
|
|
|
|
final nameMatch = contact.name.toLowerCase().contains(query);
|
|
final orgMatch = contact.organization.toLowerCase().contains(query);
|
|
final emailMatch = contact.contactEmails
|
|
.any((e) => e.emailAddress.toLowerCase().contains(query));
|
|
final phoneMatch = contact.contactPhones
|
|
.any((p) => p.phoneNumber.toLowerCase().contains(query));
|
|
final tagMatch =
|
|
contact.tags.any((tag) => tag.name.toLowerCase().contains(query));
|
|
final categoryNameMatch =
|
|
contact.contactCategory?.name.toLowerCase().contains(query) ?? false;
|
|
|
|
final bucketNameMatch = contact.bucketIds.any((id) {
|
|
final bucketName = contactBuckets
|
|
.firstWhereOrNull((b) => b.id == id)
|
|
?.name
|
|
.toLowerCase() ??
|
|
'';
|
|
return bucketName.contains(query);
|
|
});
|
|
|
|
final searchMatch = query.isEmpty ||
|
|
nameMatch ||
|
|
orgMatch ||
|
|
emailMatch ||
|
|
phoneMatch ||
|
|
tagMatch ||
|
|
categoryNameMatch ||
|
|
bucketNameMatch;
|
|
|
|
return categoryMatch && bucketMatch && searchMatch;
|
|
}).toList();
|
|
|
|
filteredContacts
|
|
.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
|
|
}
|
|
|
|
void toggleCategory(String categoryId) {
|
|
if (selectedCategories.contains(categoryId)) {
|
|
selectedCategories.remove(categoryId);
|
|
} else {
|
|
selectedCategories.add(categoryId);
|
|
}
|
|
}
|
|
|
|
void toggleBucket(String bucketId) {
|
|
if (selectedBuckets.contains(bucketId)) {
|
|
selectedBuckets.remove(bucketId);
|
|
} else {
|
|
selectedBuckets.add(bucketId);
|
|
}
|
|
}
|
|
|
|
void updateSearchQuery(String value) {
|
|
searchQuery.value = value;
|
|
applyFilters();
|
|
}
|
|
|
|
String getBucketNames(ContactModel contact, List<ContactBucket> allBuckets) {
|
|
return contact.bucketIds
|
|
.map((id) => allBuckets.firstWhereOrNull((b) => b.id == id)?.name ?? '')
|
|
.where((name) => name.isNotEmpty)
|
|
.join(', ');
|
|
}
|
|
|
|
bool hasActiveFilters() {
|
|
return selectedCategories.isNotEmpty ||
|
|
selectedBuckets.isNotEmpty ||
|
|
searchQuery.value.trim().isNotEmpty;
|
|
}
|
|
}
|