924367c70e
Snackbar Improvements: - All snackbars now have colored backgrounds (green/red/orange/blue) - Added icons to snackbar messages (check_circle, error, warning, info) - Floating behavior with bottom margin to avoid obscuring action buttons - Consistent styling across menu_browse, cart_view, and login screens App State Fixes: - Clear cartItemCount when switching businesses (setBusiness, setServicePoint, setBusinessAndServicePoint, clearAll) - Prevents stale cart count showing after switching restaurants 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
781 lines
24 KiB
Dart
781 lines
24 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
import '../app/app_state.dart';
|
|
import '../main.dart' show rootScaffoldMessengerKey;
|
|
import '../models/cart.dart';
|
|
import '../models/menu_item.dart';
|
|
import '../services/api.dart';
|
|
import '../services/order_polling_service.dart';
|
|
import '../services/stripe_service.dart';
|
|
|
|
/// Helper class to store modifier breadcrumb paths
|
|
class ModifierPath {
|
|
final List<String> names;
|
|
final double price;
|
|
|
|
const ModifierPath({
|
|
required this.names,
|
|
required this.price,
|
|
});
|
|
}
|
|
|
|
class CartViewScreen extends StatefulWidget {
|
|
const CartViewScreen({super.key});
|
|
|
|
@override
|
|
State<CartViewScreen> createState() => _CartViewScreenState();
|
|
}
|
|
|
|
class _CartViewScreenState extends State<CartViewScreen> {
|
|
Cart? _cart;
|
|
bool _isLoading = true;
|
|
bool _isProcessingPayment = false;
|
|
String? _error;
|
|
Map<int, MenuItem> _menuItemsById = {};
|
|
|
|
// Tip options as percentages
|
|
static const List<int> _tipPercentages = [0, 15, 18, 20, 25];
|
|
int _selectedTipIndex = 1; // Default to 15%
|
|
|
|
double get _tipAmount {
|
|
if (_cart == null) return 0.0;
|
|
return _cart!.subtotal * (_tipPercentages[_selectedTipIndex] / 100);
|
|
}
|
|
|
|
FeeBreakdown get _feeBreakdown {
|
|
if (_cart == null) {
|
|
return const FeeBreakdown(
|
|
subtotal: 0,
|
|
tax: 0,
|
|
tip: 0,
|
|
payfritFee: 0,
|
|
cardFee: 0,
|
|
total: 0,
|
|
);
|
|
}
|
|
return StripeService.calculateFees(
|
|
subtotal: _cart!.subtotal,
|
|
tax: _cart!.tax,
|
|
tip: _tipAmount,
|
|
);
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_loadCart();
|
|
}
|
|
|
|
Future<void> _loadCart() async {
|
|
setState(() {
|
|
_isLoading = true;
|
|
_error = null;
|
|
});
|
|
|
|
try {
|
|
final appState = context.read<AppState>();
|
|
final cartOrderId = appState.cartOrderId;
|
|
|
|
if (cartOrderId == null) {
|
|
setState(() {
|
|
_isLoading = false;
|
|
_cart = null;
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Load cart
|
|
final cart = await Api.getCart(orderId: cartOrderId);
|
|
|
|
// Load menu items to get names and prices
|
|
final businessId = appState.selectedBusinessId;
|
|
if (businessId != null) {
|
|
final menuItems = await Api.listMenuItems(businessId: businessId);
|
|
_menuItemsById = {for (var item in menuItems) item.itemId: item};
|
|
}
|
|
|
|
setState(() {
|
|
_cart = cart;
|
|
_isLoading = false;
|
|
});
|
|
|
|
// Update item count in app state
|
|
appState.updateCartItemCount(cart.itemCount);
|
|
} catch (e) {
|
|
// If cart not found (deleted or doesn't exist), clear it from app state
|
|
if (e.toString().contains('not_found') || e.toString().contains('Order not found')) {
|
|
final appState = context.read<AppState>();
|
|
appState.clearCart();
|
|
setState(() {
|
|
_cart = null;
|
|
_isLoading = false;
|
|
});
|
|
} else {
|
|
setState(() {
|
|
_error = e.toString();
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _removeLineItem(OrderLineItem lineItem) async {
|
|
try {
|
|
final appState = context.read<AppState>();
|
|
final cartOrderId = appState.cartOrderId;
|
|
if (cartOrderId == null) return;
|
|
|
|
setState(() => _isLoading = true);
|
|
|
|
// Set IsSelected=false to remove the item
|
|
await Api.setLineItem(
|
|
orderId: cartOrderId,
|
|
parentOrderLineItemId: lineItem.parentOrderLineItemId,
|
|
itemId: lineItem.itemId,
|
|
isSelected: false,
|
|
);
|
|
|
|
// Reload cart
|
|
await _loadCart();
|
|
} catch (e) {
|
|
setState(() {
|
|
_error = e.toString();
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
Future<void> _updateQuantity(OrderLineItem lineItem, int newQuantity) async {
|
|
if (newQuantity < 1) return;
|
|
|
|
try {
|
|
final appState = context.read<AppState>();
|
|
final cartOrderId = appState.cartOrderId;
|
|
if (cartOrderId == null) return;
|
|
|
|
setState(() => _isLoading = true);
|
|
|
|
await Api.setLineItem(
|
|
orderId: cartOrderId,
|
|
parentOrderLineItemId: lineItem.parentOrderLineItemId,
|
|
itemId: lineItem.itemId,
|
|
isSelected: true,
|
|
quantity: newQuantity,
|
|
remark: lineItem.remark,
|
|
);
|
|
|
|
// Reload cart
|
|
await _loadCart();
|
|
} catch (e) {
|
|
setState(() {
|
|
_error = e.toString();
|
|
_isLoading = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
Future<void> _processPaymentAndSubmit() async {
|
|
if (_cart == null) return;
|
|
|
|
final appState = context.read<AppState>();
|
|
final cartOrderId = appState.cartOrderId;
|
|
final businessId = appState.selectedBusinessId;
|
|
|
|
if (cartOrderId == null || businessId == null) return;
|
|
|
|
setState(() => _isProcessingPayment = true);
|
|
|
|
try {
|
|
// 1. Process payment with Stripe
|
|
final paymentResult = await StripeService.processPayment(
|
|
context: context,
|
|
businessId: businessId,
|
|
orderId: cartOrderId,
|
|
subtotal: _cart!.subtotal,
|
|
tax: _cart!.tax,
|
|
tip: _tipAmount,
|
|
);
|
|
|
|
if (!paymentResult.success) {
|
|
if (!mounted) return;
|
|
setState(() => _isProcessingPayment = false);
|
|
|
|
if (paymentResult.error != 'Payment cancelled') {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Row(
|
|
children: [
|
|
Icon(Icons.error, color: Colors.white),
|
|
SizedBox(width: 8),
|
|
Expanded(child: Text(paymentResult.error ?? 'Payment failed')),
|
|
],
|
|
),
|
|
backgroundColor: Colors.red,
|
|
behavior: SnackBarBehavior.floating,
|
|
margin: const EdgeInsets.only(bottom: 80, left: 16, right: 16),
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// 2. Payment successful, now submit the order
|
|
await Api.submitOrder(orderId: cartOrderId);
|
|
|
|
// Set active order for polling (status 1 = submitted)
|
|
appState.setActiveOrder(orderId: cartOrderId, statusId: 1);
|
|
|
|
// Start polling for status updates
|
|
OrderPollingService.startPolling(
|
|
orderId: cartOrderId,
|
|
initialStatusId: 1,
|
|
onStatusUpdate: (update) {
|
|
// Update app state
|
|
appState.updateActiveOrderStatus(update.statusId);
|
|
|
|
// Show notification using global scaffold messenger key
|
|
// This works even after the cart screen is popped
|
|
rootScaffoldMessengerKey.currentState?.showSnackBar(
|
|
SnackBar(
|
|
content: Row(
|
|
children: [
|
|
Icon(Icons.notifications_active, color: Colors.white),
|
|
SizedBox(width: 8),
|
|
Expanded(child: Text(update.message)),
|
|
],
|
|
),
|
|
backgroundColor: _getStatusColorStatic(update.statusId),
|
|
duration: const Duration(seconds: 5),
|
|
behavior: SnackBarBehavior.floating,
|
|
margin: const EdgeInsets.only(bottom: 80, left: 16, right: 16),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
|
|
// Clear cart state
|
|
appState.clearCart();
|
|
|
|
if (!mounted) return;
|
|
|
|
// Show success message
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: const Row(
|
|
children: [
|
|
Icon(Icons.check_circle, color: Colors.white),
|
|
SizedBox(width: 8),
|
|
Expanded(
|
|
child: Text(
|
|
"Payment successful! Order placed. You'll receive notifications as your order is prepared.",
|
|
),
|
|
),
|
|
],
|
|
),
|
|
backgroundColor: Colors.green,
|
|
duration: const Duration(seconds: 5),
|
|
behavior: SnackBarBehavior.floating,
|
|
margin: const EdgeInsets.only(bottom: 80, left: 16, right: 16),
|
|
),
|
|
);
|
|
|
|
// Navigate back
|
|
Navigator.of(context).pop();
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() => _isProcessingPayment = false);
|
|
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Row(
|
|
children: [
|
|
const Icon(Icons.error, color: Colors.white),
|
|
const SizedBox(width: 8),
|
|
Expanded(child: Text('Error: ${e.toString()}')),
|
|
],
|
|
),
|
|
backgroundColor: Colors.red,
|
|
behavior: SnackBarBehavior.floating,
|
|
margin: const EdgeInsets.only(bottom: 80, left: 16, right: 16),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
Color _getStatusColor(int statusId) => _getStatusColorStatic(statusId);
|
|
|
|
static Color _getStatusColorStatic(int statusId) {
|
|
switch (statusId) {
|
|
case 1: // Submitted
|
|
return Colors.blue;
|
|
case 2: // Preparing
|
|
return Colors.orange;
|
|
case 3: // Ready
|
|
return Colors.green;
|
|
case 4: // Completed
|
|
return Colors.purple;
|
|
default:
|
|
return Colors.grey;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: const Text("Cart"),
|
|
backgroundColor: Colors.black,
|
|
foregroundColor: Colors.white,
|
|
),
|
|
body: _isLoading
|
|
? const Center(child: CircularProgressIndicator())
|
|
: _error != null
|
|
? Center(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(16),
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
const Icon(Icons.error, color: Colors.red, size: 48),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
"Error loading cart",
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 8),
|
|
Text(_error!, textAlign: TextAlign.center),
|
|
const SizedBox(height: 16),
|
|
ElevatedButton(
|
|
onPressed: _loadCart,
|
|
child: const Text("Retry"),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
)
|
|
: _cart == null || _cart!.itemCount == 0
|
|
? Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
const Icon(
|
|
Icons.shopping_cart_outlined,
|
|
size: 80,
|
|
color: Colors.grey,
|
|
),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
"Your cart is empty",
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
],
|
|
),
|
|
)
|
|
: Column(
|
|
children: [
|
|
Expanded(
|
|
child: ListView(
|
|
padding: const EdgeInsets.all(16),
|
|
children: _buildCartItems(),
|
|
),
|
|
),
|
|
_buildCartSummary(),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
List<Widget> _buildCartItems() {
|
|
if (_cart == null) return [];
|
|
|
|
// Group line items by root items
|
|
final rootItems = _cart!.lineItems
|
|
.where((item) => item.parentOrderLineItemId == 0 && !item.isDeleted)
|
|
.toList();
|
|
|
|
final widgets = <Widget>[];
|
|
|
|
for (final rootItem in rootItems) {
|
|
widgets.add(_buildRootItemCard(rootItem));
|
|
widgets.add(const SizedBox(height: 12));
|
|
}
|
|
|
|
return widgets;
|
|
}
|
|
|
|
Widget _buildRootItemCard(OrderLineItem rootItem) {
|
|
final menuItem = _menuItemsById[rootItem.itemId];
|
|
final itemName = menuItem?.name ?? "Item #${rootItem.itemId}";
|
|
|
|
print('[Cart] Building card for root item: $itemName (OrderLineItemID=${rootItem.orderLineItemId})');
|
|
print('[Cart] Total line items in cart: ${_cart!.lineItems.length}');
|
|
|
|
// Find ALL modifiers (recursively) and build breadcrumb paths for leaf items only
|
|
final modifierPaths = _buildModifierPaths(rootItem.orderLineItemId);
|
|
|
|
// Calculate total price for this line item (root + all modifiers)
|
|
final lineItemTotal = _calculateLineItemTotal(rootItem);
|
|
|
|
print('[Cart] Found ${modifierPaths.length} modifier paths for this root item');
|
|
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(12),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
itemName,
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.delete, color: Colors.red),
|
|
onPressed: () => _confirmRemoveItem(rootItem, itemName),
|
|
),
|
|
],
|
|
),
|
|
if (modifierPaths.isNotEmpty) ...[
|
|
const SizedBox(height: 8),
|
|
...modifierPaths.map((path) => _buildModifierPathRow(path)),
|
|
],
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
IconButton(
|
|
icon: const Icon(Icons.remove_circle_outline),
|
|
onPressed: rootItem.quantity > 1
|
|
? () => _updateQuantity(rootItem, rootItem.quantity - 1)
|
|
: null,
|
|
),
|
|
Text(
|
|
"${rootItem.quantity}",
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.add_circle_outline),
|
|
onPressed: () =>
|
|
_updateQuantity(rootItem, rootItem.quantity + 1),
|
|
),
|
|
const Spacer(),
|
|
Text(
|
|
"\$${lineItemTotal.toStringAsFixed(2)}",
|
|
style: const TextStyle(
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Calculate the total price for a root item including all its modifiers
|
|
double _calculateLineItemTotal(OrderLineItem rootItem) {
|
|
double total = rootItem.price * rootItem.quantity;
|
|
total += _sumModifierPrices(rootItem.orderLineItemId, rootItem.quantity);
|
|
return total;
|
|
}
|
|
|
|
/// Recursively sum modifier prices for a parent line item
|
|
double _sumModifierPrices(int parentOrderLineItemId, int rootQuantity) {
|
|
double total = 0.0;
|
|
final children = _cart!.lineItems.where(
|
|
(item) => !item.isDeleted && item.parentOrderLineItemId == parentOrderLineItemId
|
|
);
|
|
|
|
for (final child in children) {
|
|
// Modifier price is multiplied by root item quantity
|
|
total += child.price * rootQuantity;
|
|
// Recursively add grandchildren modifier prices
|
|
total += _sumModifierPrices(child.orderLineItemId, rootQuantity);
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/// Build breadcrumb paths for all leaf modifiers
|
|
/// Excludes default items - they don't need to be shown in the cart
|
|
List<ModifierPath> _buildModifierPaths(int rootOrderLineItemId) {
|
|
final paths = <ModifierPath>[];
|
|
|
|
// Get direct children of root
|
|
final directChildren = _cart!.lineItems
|
|
.where((item) =>
|
|
item.parentOrderLineItemId == rootOrderLineItemId &&
|
|
!item.isDeleted)
|
|
.toList();
|
|
|
|
// Recursively collect leaf items with their paths
|
|
void collectLeafPaths(OrderLineItem item, List<String> currentPath) {
|
|
final menuItem = _menuItemsById[item.itemId];
|
|
|
|
// Skip default items - they don't need to be repeated in the cart
|
|
if (menuItem?.isCheckedByDefault == true) {
|
|
return;
|
|
}
|
|
|
|
final children = _cart!.lineItems
|
|
.where((child) =>
|
|
child.parentOrderLineItemId == item.orderLineItemId &&
|
|
!child.isDeleted)
|
|
.toList();
|
|
|
|
final itemName = menuItem?.name ?? "Item #${item.itemId}";
|
|
|
|
if (children.isEmpty) {
|
|
// This is a leaf - add its path
|
|
paths.add(ModifierPath(
|
|
names: [...currentPath, itemName],
|
|
price: item.price,
|
|
));
|
|
} else {
|
|
// This has children - recurse into them
|
|
for (final child in children) {
|
|
collectLeafPaths(child, [...currentPath, itemName]);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (final child in directChildren) {
|
|
collectLeafPaths(child, []);
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
Widget _buildModifierPathRow(ModifierPath path) {
|
|
final displayText = path.names.join(' > ');
|
|
|
|
return Padding(
|
|
padding: const EdgeInsets.only(left: 16, top: 4),
|
|
child: Row(
|
|
children: [
|
|
const Icon(Icons.add, size: 12, color: Colors.grey),
|
|
const SizedBox(width: 4),
|
|
Expanded(
|
|
child: Text(
|
|
displayText,
|
|
style: const TextStyle(
|
|
fontSize: 14,
|
|
color: Colors.grey,
|
|
),
|
|
),
|
|
),
|
|
if (path.price > 0)
|
|
Text(
|
|
"+\$${path.price.toStringAsFixed(2)}",
|
|
style: const TextStyle(
|
|
fontSize: 14,
|
|
color: Colors.grey,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildCartSummary() {
|
|
if (_cart == null) return const SizedBox.shrink();
|
|
|
|
final fees = _feeBreakdown;
|
|
|
|
return Container(
|
|
decoration: BoxDecoration(
|
|
color: Colors.grey[100],
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: Colors.black.withOpacity(0.1),
|
|
blurRadius: 4,
|
|
offset: const Offset(0, -2),
|
|
),
|
|
],
|
|
),
|
|
padding: const EdgeInsets.all(16),
|
|
child: SafeArea(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
// Tip Selection
|
|
const Text(
|
|
"Add a tip",
|
|
style: TextStyle(fontSize: 16, fontWeight: FontWeight.w600),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: List.generate(_tipPercentages.length, (index) {
|
|
final isSelected = _selectedTipIndex == index;
|
|
final percent = _tipPercentages[index];
|
|
return Expanded(
|
|
child: Padding(
|
|
padding: EdgeInsets.only(
|
|
left: index == 0 ? 0 : 4,
|
|
right: index == _tipPercentages.length - 1 ? 0 : 4,
|
|
),
|
|
child: GestureDetector(
|
|
onTap: () => setState(() => _selectedTipIndex = index),
|
|
child: Container(
|
|
padding: const EdgeInsets.symmetric(vertical: 10),
|
|
decoration: BoxDecoration(
|
|
color: isSelected ? Colors.black : Colors.white,
|
|
borderRadius: BorderRadius.circular(8),
|
|
border: Border.all(
|
|
color: isSelected ? Colors.black : Colors.grey.shade300,
|
|
),
|
|
),
|
|
child: Center(
|
|
child: Text(
|
|
percent == 0 ? "No tip" : "$percent%",
|
|
style: TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: isSelected ? FontWeight.bold : FontWeight.normal,
|
|
color: isSelected ? Colors.white : Colors.black,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}),
|
|
),
|
|
const SizedBox(height: 16),
|
|
const Divider(height: 1),
|
|
const SizedBox(height: 12),
|
|
// Subtotal
|
|
_buildSummaryRow("Subtotal", fees.subtotal),
|
|
const SizedBox(height: 6),
|
|
// Tax
|
|
_buildSummaryRow("Tax (8.25%)", fees.tax),
|
|
// Only show delivery fee for delivery orders (OrderTypeID = 3)
|
|
if (_cart!.deliveryFee > 0 && _cart!.orderTypeId == 3) ...[
|
|
const SizedBox(height: 6),
|
|
_buildSummaryRow("Delivery Fee", _cart!.deliveryFee),
|
|
],
|
|
// Tip
|
|
if (_tipAmount > 0) ...[
|
|
const SizedBox(height: 6),
|
|
_buildSummaryRow("Tip", _tipAmount),
|
|
],
|
|
const SizedBox(height: 6),
|
|
// Payfrit fee
|
|
_buildSummaryRow("Service Fee", fees.payfritFee, isGrey: true),
|
|
const SizedBox(height: 6),
|
|
// Card processing fee
|
|
_buildSummaryRow("Card Processing", fees.cardFee, isGrey: true),
|
|
const SizedBox(height: 12),
|
|
const Divider(height: 1),
|
|
const SizedBox(height: 12),
|
|
// Total
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
const Text(
|
|
"Total",
|
|
style: TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
Text(
|
|
"\$${fees.total.toStringAsFixed(2)}",
|
|
style: const TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 16),
|
|
SizedBox(
|
|
width: double.infinity,
|
|
child: ElevatedButton(
|
|
onPressed: (_cart!.itemCount > 0 && !_isProcessingPayment)
|
|
? _processPaymentAndSubmit
|
|
: null,
|
|
style: ElevatedButton.styleFrom(
|
|
backgroundColor: Colors.black,
|
|
foregroundColor: Colors.white,
|
|
padding: const EdgeInsets.symmetric(vertical: 16),
|
|
disabledBackgroundColor: Colors.grey,
|
|
),
|
|
child: _isProcessingPayment
|
|
? const SizedBox(
|
|
height: 20,
|
|
width: 20,
|
|
child: CircularProgressIndicator(
|
|
strokeWidth: 2,
|
|
valueColor: AlwaysStoppedAnimation<Color>(Colors.white),
|
|
),
|
|
)
|
|
: Text(
|
|
"Pay \$${fees.total.toStringAsFixed(2)}",
|
|
style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildSummaryRow(String label, double amount, {bool isGrey = false}) {
|
|
return Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Text(
|
|
label,
|
|
style: TextStyle(
|
|
fontSize: 15,
|
|
color: isGrey ? Colors.grey.shade600 : Colors.black,
|
|
),
|
|
),
|
|
Text(
|
|
"\$${amount.toStringAsFixed(2)}",
|
|
style: TextStyle(
|
|
fontSize: 15,
|
|
color: isGrey ? Colors.grey.shade600 : Colors.black,
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
void _confirmRemoveItem(OrderLineItem item, String itemName) {
|
|
showDialog(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: const Text("Remove Item"),
|
|
content: Text("Remove $itemName from cart?"),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text("Cancel"),
|
|
),
|
|
TextButton(
|
|
onPressed: () {
|
|
Navigator.of(context).pop();
|
|
_removeLineItem(item);
|
|
},
|
|
style: TextButton.styleFrom(foregroundColor: Colors.red),
|
|
child: const Text("Remove"),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|