681 lines
20 KiB
Dart
681 lines
20 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:qpay/http/http.dart';
|
|
import 'package:qpay/models/api_response.dart';
|
|
import 'package:qpay/screens/groups/models/group_batch_model.dart';
|
|
import 'package:qpay/models/pageable_model.dart';
|
|
import 'package:qpay/screens/home/home_controller.dart';
|
|
import 'package:qpay/screens/pay/pay_controller.dart';
|
|
import 'package:qpay/screens/transactions/transaction_model.dart';
|
|
|
|
import '../models/batch_item_update_model.dart';
|
|
|
|
class BatchScreenModel {
|
|
List<GroupBatch> batches = [];
|
|
List<GroupBatchItem> batchItems = [];
|
|
GroupBatch? currentBatch;
|
|
List<BillProvider> providers = [];
|
|
List<PaymentProcessor> processors = [];
|
|
BillProvider? selectedProvider;
|
|
PaymentProcessor? selectedProcessor;
|
|
bool isLoading = false;
|
|
bool isLoadingMore = false;
|
|
bool isActing = false;
|
|
String? errorMessage;
|
|
int currentPage = 0;
|
|
int totalPages = 0;
|
|
int totalElements = 0;
|
|
String searchQuery = '';
|
|
String? statusFilter;
|
|
String? currencyFilter;
|
|
bool selectMode = false;
|
|
Set<String> selectedBatchIds = {};
|
|
|
|
// Batch items pagination state
|
|
int batchItemsCurrentPage = 0;
|
|
int batchItemsTotalPages = 0;
|
|
int batchItemsTotalElements = 0;
|
|
String batchItemsSearchQuery = '';
|
|
String? batchItemsStatusFilter;
|
|
String? batchItemsRecipientAccount;
|
|
bool batchItemsIsLoadingMore = false;
|
|
|
|
// Provider products cache: providerId -> list of products
|
|
Map<String, List<BillProduct>> providerProducts = {};
|
|
Set<String> loadingProviderProducts = {};
|
|
}
|
|
|
|
class BatchController extends ChangeNotifier {
|
|
final BatchScreenModel model = BatchScreenModel();
|
|
final Http http = Http();
|
|
BuildContext context;
|
|
bool _disposed = false;
|
|
|
|
BatchController(this.context);
|
|
|
|
@override
|
|
void dispose() {
|
|
_disposed = true;
|
|
super.dispose();
|
|
}
|
|
|
|
dynamic _unwrap(dynamic response) {
|
|
if (response is Map && response.containsKey('body')) {
|
|
return response['body'];
|
|
}
|
|
return response;
|
|
}
|
|
|
|
String buildQueryParameters(Map<String, String> params) {
|
|
if (params.isEmpty) {
|
|
return '';
|
|
}
|
|
|
|
String query = '';
|
|
params.forEach((key, value) {
|
|
query += '$key=$value&';
|
|
});
|
|
return query.substring(0, query.length - 1);
|
|
}
|
|
|
|
Future<ApiResponse<List<BillProvider>>> loadProviders(String currency) async {
|
|
try {
|
|
final raw = await http.get(
|
|
'/public/providers?currency=$currency&sort=priority,asc',
|
|
);
|
|
final response = _unwrap(raw);
|
|
final List<dynamic> content;
|
|
if (response is Map && response.containsKey('content')) {
|
|
content = response['content'] as List<dynamic>;
|
|
} else if (response is List) {
|
|
content = response;
|
|
} else {
|
|
content = [];
|
|
}
|
|
model.providers = content
|
|
.map((e) => BillProvider.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
if (model.providers.isNotEmpty) {
|
|
model.selectedProvider = model.providers.first;
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(model.providers);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
return ApiResponse.failure('Failed to load providers');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<List<PaymentProcessor>>> loadProcessors(currency) async {
|
|
try {
|
|
final raw = await http.get(
|
|
'/public/payment-processors?currency=$currency',
|
|
);
|
|
final response = _unwrap(raw);
|
|
final List<dynamic> content = response is List
|
|
? response
|
|
: (response['content'] ?? []);
|
|
model.processors = content
|
|
.map((e) => PaymentProcessor.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
if (model.processors.isNotEmpty) {
|
|
model.selectedProcessor = model.processors.first;
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(model.processors);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
return ApiResponse.failure('Failed to load processors');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<List<BillProduct>>> loadProviderProducts(
|
|
String providerId,
|
|
) async {
|
|
if (model.loadingProviderProducts.contains(providerId)) {
|
|
// Already loading, return cached data if available
|
|
final cached = model.providerProducts[providerId];
|
|
if (cached != null) {
|
|
return ApiResponse.success(cached);
|
|
}
|
|
return ApiResponse.failure('Loading in progress');
|
|
}
|
|
|
|
model.loadingProviderProducts.add(providerId);
|
|
if (!_disposed) notifyListeners();
|
|
|
|
try {
|
|
final raw = await http.get('/public/providers/$providerId/products');
|
|
final response = _unwrap(raw);
|
|
final List<dynamic> list = response is List
|
|
? response
|
|
: (response['content'] ?? []);
|
|
final products = list
|
|
.map((e) => BillProduct.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
model.providerProducts[providerId] = products;
|
|
model.loadingProviderProducts.remove(providerId);
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(products);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.loadingProviderProducts.remove(providerId);
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to load products');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<List<GroupBatch>>> listBatches(
|
|
String groupId, {
|
|
int page = 0,
|
|
int size = 20,
|
|
String? search,
|
|
String? status,
|
|
String? currency,
|
|
}) async {
|
|
if (page == 0) {
|
|
model.isLoading = true;
|
|
model.batches = [];
|
|
model.currentPage = 0;
|
|
} else {
|
|
model.isLoadingMore = true;
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
|
|
try {
|
|
final params = <String, String>{
|
|
'recipientGroupId': groupId,
|
|
'page': page.toString(),
|
|
'size': size.toString(),
|
|
'sort': 'createdAt,desc',
|
|
};
|
|
if (search != null && search.isNotEmpty) {
|
|
params['description'] = search;
|
|
}
|
|
if (status != null && status.isNotEmpty) {
|
|
params['status'] = status;
|
|
}
|
|
if (currency != null && currency.isNotEmpty) {
|
|
params['currency'] = currency;
|
|
}
|
|
|
|
final raw = await http.get(
|
|
'/group-batches?${buildQueryParameters(params)}',
|
|
);
|
|
final response = _unwrap(raw);
|
|
final pageableModel = PageableModel.fromJson(
|
|
response as Map<String, dynamic>,
|
|
);
|
|
|
|
final newBatches = pageableModel.content
|
|
.map((e) => GroupBatch.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
|
|
if (page == 0) {
|
|
model.batches = newBatches;
|
|
} else {
|
|
model.batches.addAll(newBatches);
|
|
}
|
|
model.currentPage = pageableModel.number;
|
|
model.totalPages = pageableModel.totalPages;
|
|
model.totalElements = pageableModel.totalElements;
|
|
model.isLoading = false;
|
|
model.isLoadingMore = false;
|
|
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(model.batches);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.errorMessage = e.toString();
|
|
if (page == 0) {
|
|
model.batches = [];
|
|
}
|
|
model.isLoading = false;
|
|
model.isLoadingMore = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to load batches');
|
|
}
|
|
}
|
|
|
|
Future<void> searchBatches(
|
|
String groupId, {
|
|
String? search,
|
|
String? status,
|
|
String? currency,
|
|
}) async {
|
|
model.searchQuery = search ?? '';
|
|
model.statusFilter = status;
|
|
model.currencyFilter = currency;
|
|
await listBatches(
|
|
groupId,
|
|
page: 0,
|
|
search: search,
|
|
status: status,
|
|
currency: currency,
|
|
);
|
|
}
|
|
|
|
Future<void> loadNextPage(String groupId) async {
|
|
if (model.isLoadingMore || model.currentPage + 1 >= model.totalPages) {
|
|
return;
|
|
}
|
|
await listBatches(
|
|
groupId,
|
|
page: model.currentPage + 1,
|
|
search: model.searchQuery.isNotEmpty ? model.searchQuery : null,
|
|
status: model.statusFilter,
|
|
currency: model.currencyFilter,
|
|
);
|
|
}
|
|
|
|
Future<ApiResponse<List<GroupBatchItem>>> listBatchItems(
|
|
String batchId, {
|
|
int page = 0,
|
|
int size = 20,
|
|
Map<String, String>? filters,
|
|
}) async {
|
|
if (page == 0) {
|
|
model.isLoading = true;
|
|
model.batchItems = [];
|
|
model.batchItemsCurrentPage = 0;
|
|
} else {
|
|
model.batchItemsIsLoadingMore = true;
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
|
|
try {
|
|
final params = <String, String>{
|
|
'groupBatchId': batchId,
|
|
'page': page.toString(),
|
|
'size': size.toString(),
|
|
'sort': 'createdAt,desc',
|
|
};
|
|
if (filters != null) {
|
|
params.addAll(filters);
|
|
}
|
|
|
|
final raw = await http.get(
|
|
'/group-batches/items?${buildQueryParameters(params)}',
|
|
);
|
|
final response = _unwrap(raw);
|
|
final pageableModel = PageableModel.fromJson(
|
|
response as Map<String, dynamic>,
|
|
);
|
|
|
|
final newItems = pageableModel.content
|
|
.map((e) => GroupBatchItem.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
|
|
if (page == 0) {
|
|
model.batchItems = newItems;
|
|
} else {
|
|
model.batchItems.addAll(newItems);
|
|
}
|
|
model.batchItemsCurrentPage = pageableModel.number;
|
|
model.batchItemsTotalPages = pageableModel.totalPages;
|
|
model.batchItemsTotalElements = pageableModel.totalElements;
|
|
model.isLoading = false;
|
|
model.batchItemsIsLoadingMore = false;
|
|
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(model.batchItems);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.errorMessage = e.toString();
|
|
if (page == 0) {
|
|
model.batchItems = [];
|
|
}
|
|
model.isLoading = false;
|
|
model.batchItemsIsLoadingMore = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to load batch items');
|
|
}
|
|
}
|
|
|
|
Future<void> searchBatchItems(
|
|
String batchId, {
|
|
String? search,
|
|
String? status,
|
|
String? account,
|
|
}) async {
|
|
model.batchItemsSearchQuery = search ?? '';
|
|
model.batchItemsStatusFilter = status;
|
|
model.batchItemsRecipientAccount = account;
|
|
await listBatchItems(
|
|
batchId,
|
|
page: 0,
|
|
filters: _buildBatchItemFilters(
|
|
search: search,
|
|
status: status,
|
|
account: account,
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> loadNextBatchItemsPage(String batchId) async {
|
|
if (model.batchItemsIsLoadingMore ||
|
|
model.batchItemsCurrentPage + 1 >= model.batchItemsTotalPages) {
|
|
return;
|
|
}
|
|
await listBatchItems(
|
|
batchId,
|
|
page: model.batchItemsCurrentPage + 1,
|
|
filters: _buildBatchItemFilters(
|
|
search: model.batchItemsSearchQuery.isNotEmpty
|
|
? model.batchItemsSearchQuery
|
|
: null,
|
|
status: model.batchItemsStatusFilter,
|
|
account: model.batchItemsRecipientAccount,
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Builds the filters map for batch items queries from individual params.
|
|
Map<String, String>? _buildBatchItemFilters({
|
|
String? search,
|
|
String? status,
|
|
String? account,
|
|
}) {
|
|
final filters = <String, String>{};
|
|
if (search != null && search.isNotEmpty) {
|
|
filters['recipientName'] = search;
|
|
}
|
|
if (status != null && status.isNotEmpty) {
|
|
filters['status'] = status;
|
|
}
|
|
if (account != null && account.isNotEmpty) {
|
|
filters['recipientAccount'] = account;
|
|
}
|
|
return filters.isEmpty ? null : filters;
|
|
}
|
|
|
|
Future<ApiResponse<GroupBatch>> getBatch(
|
|
String batchId,
|
|
String workspaceId,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final raw = await http.get(
|
|
'/group-batches/$batchId?workspaceId=$workspaceId',
|
|
);
|
|
final response = _unwrap(raw);
|
|
final batch = GroupBatch.fromJson(response as Map<String, dynamic>);
|
|
model.currentBatch = batch;
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(batch);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to load batch');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<GroupBatch>> createBatch(CreateBatchRequest req) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final raw = await http.post('/group-batches', req.toJson());
|
|
final response = _unwrap(raw);
|
|
final batch = GroupBatch.fromJson(response as Map<String, dynamic>);
|
|
model.currentBatch = batch;
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(batch);
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to create batch');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<GroupBatch>> updateBatch(
|
|
GroupBatchUpdateRequest request,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final raw = await http.put(
|
|
'/group-batches/${request.id}',
|
|
request.toJson(),
|
|
);
|
|
final response = _unwrap(raw);
|
|
final batch = GroupBatch.fromJson(response as Map<String, dynamic>);
|
|
// Update the batch in the local list if present
|
|
final index = model.batches.indexWhere((b) => b.id == batch.id);
|
|
if (index != -1) {
|
|
model.batches[index] = batch;
|
|
}
|
|
model.currentBatch = batch;
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(batch);
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to update batch');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<List<GroupBatchItem>>> updateBatchItems(
|
|
String batchId,
|
|
GroupBatchItemUpdateList updateList,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final raw = await http.put(
|
|
'/group-batches/$batchId/items',
|
|
updateList.toJson(),
|
|
);
|
|
final response = _unwrap(raw);
|
|
final items = (response as List<dynamic>)
|
|
.map((e) => GroupBatchItem.fromJson(e as Map<String, dynamic>))
|
|
.toList();
|
|
// Update items in the local batch items list if the current batch matches
|
|
model.batchItems = items;
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(items);
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to update batch items');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<GroupBatch>> confirmBatch(
|
|
String batchId,
|
|
String workspaceId,
|
|
String authType,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final key =
|
|
'batch-$batchId-confirm-${DateTime.now().millisecondsSinceEpoch}';
|
|
final body = BatchActionRequest(
|
|
workspaceId: workspaceId,
|
|
authType: authType,
|
|
idempotencyKey: key,
|
|
);
|
|
final raw = await http.post(
|
|
'/group-batches/$batchId/confirm',
|
|
body.toJson(),
|
|
);
|
|
final response = _unwrap(raw);
|
|
final batch = GroupBatch.fromJson(response as Map<String, dynamic>);
|
|
model.currentBatch = batch;
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(batch);
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to confirm batch');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<TransactionModel>> requestBatch(
|
|
String batchId,
|
|
String workspaceId,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final key =
|
|
'batch-$batchId-request-${DateTime.now().millisecondsSinceEpoch}';
|
|
final body = BatchActionRequest(
|
|
workspaceId: workspaceId,
|
|
idempotencyKey: key,
|
|
);
|
|
final raw = await http.post(
|
|
'/group-batches/$batchId/request',
|
|
body.toJson(),
|
|
);
|
|
final response = _unwrap(raw);
|
|
final txn = TransactionModel.fromJson(response as Map<String, dynamic>);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(txn);
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to request batch payment');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<Map<String, dynamic>>> downloadBatchReport(
|
|
String batchId,
|
|
String workspaceId,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final raw = await http.get(
|
|
'/group-batches/$batchId/report?workspaceId=$workspaceId',
|
|
);
|
|
final response = _unwrap(raw);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.success(response as Map<String, dynamic>);
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to download batch report');
|
|
}
|
|
}
|
|
|
|
Future<ApiResponse<TransactionModel>> pollBatch(
|
|
String batchId,
|
|
String workspaceId,
|
|
) async {
|
|
model.isActing = true;
|
|
if (!_disposed) notifyListeners();
|
|
try {
|
|
final key =
|
|
'batch-$batchId-poll-${DateTime.now().millisecondsSinceEpoch}';
|
|
final body = BatchActionRequest(
|
|
workspaceId: workspaceId,
|
|
idempotencyKey: key,
|
|
);
|
|
final raw = await http.post(
|
|
'/group-batches/$batchId/poll',
|
|
body.toJson(),
|
|
);
|
|
final response = _unwrap(raw);
|
|
final batchTransaction = TransactionModel.fromJson(
|
|
response as Map<String, dynamic>,
|
|
);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
if (batchTransaction.pollingStatus == 'SUCCESS') {
|
|
return ApiResponse.success(batchTransaction);
|
|
} else {
|
|
return ApiResponse.failure(
|
|
response['errorMessage'] ?? "Transaction failed",
|
|
);
|
|
}
|
|
} catch (e, s) {
|
|
logger.e(e);
|
|
logger.e(s);
|
|
model.isActing = false;
|
|
if (!_disposed) notifyListeners();
|
|
return ApiResponse.failure('Failed to poll batch');
|
|
}
|
|
}
|
|
|
|
Future<void> deleteBatch({
|
|
required String batchId,
|
|
required String workspaceId,
|
|
}) async {
|
|
try {
|
|
await http.delete('/group-batches/$batchId?workspaceId=$workspaceId');
|
|
model.batches.removeWhere((b) => b.id == batchId);
|
|
model.selectedBatchIds.remove(batchId);
|
|
model.currentBatch = null;
|
|
if (!_disposed) notifyListeners();
|
|
} catch (e) {
|
|
logger.e(e);
|
|
model.errorMessage = e.toString();
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
}
|
|
|
|
Future<void> deleteSelectedBatches({
|
|
required String groupId,
|
|
required String workspaceId,
|
|
}) async {
|
|
final idsToDelete = List<String>.from(model.selectedBatchIds);
|
|
model.selectMode = false;
|
|
model.selectedBatchIds.clear();
|
|
if (!_disposed) notifyListeners();
|
|
|
|
for (final id in idsToDelete) {
|
|
await deleteBatch(batchId: id, workspaceId: workspaceId);
|
|
}
|
|
|
|
// Refresh after deletion
|
|
await listBatches(groupId, page: 0);
|
|
}
|
|
|
|
void selectProvider(BillProvider provider) {
|
|
model.selectedProvider = provider;
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
|
|
void selectProcessor(PaymentProcessor processor) {
|
|
model.selectedProcessor = processor;
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
|
|
void toggleSelectMode() {
|
|
model.selectMode = !model.selectMode;
|
|
if (!model.selectMode) {
|
|
model.selectedBatchIds.clear();
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
|
|
void toggleBatchSelection(String batchId) {
|
|
if (model.selectedBatchIds.contains(batchId)) {
|
|
model.selectedBatchIds.remove(batchId);
|
|
} else {
|
|
model.selectedBatchIds.add(batchId);
|
|
}
|
|
if (!_disposed) notifyListeners();
|
|
}
|
|
}
|