421 lines
11 KiB
Dart
421 lines
11 KiB
Dart
import 'package:drift/drift.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
|
|
import '../database/app_database.dart';
|
|
import '../models/bar_tab.dart';
|
|
import '../models/closed_tab.dart';
|
|
import '../models/closed_tab_item.dart';
|
|
import '../models/payment_method.dart';
|
|
import '../models/product.dart';
|
|
import '../models/tab_item.dart';
|
|
import 'product_service.dart';
|
|
|
|
abstract class BarTabService {
|
|
Future<List<BarTab>> getOpenTabs();
|
|
|
|
Future<BarTab?> getTabById(String id);
|
|
|
|
Future<BarTab> createTab({required String customerName});
|
|
|
|
Future<void> addProductToTab({
|
|
required String tabId,
|
|
required Product product,
|
|
});
|
|
|
|
Future<int> adjustTabItemQuantity({
|
|
required String tabItemId,
|
|
required int delta,
|
|
});
|
|
|
|
/// Archives the tab's current items into history and clears them.
|
|
/// The tab itself stays open under the same customer name.
|
|
Future<void> closeTab(
|
|
String tabId, {
|
|
PaymentMethod paymentMethod = PaymentMethod.cash,
|
|
});
|
|
|
|
Future<List<ClosedTab>> getClosedTabs();
|
|
|
|
Future<List<ClosedTab>> getClosedTabsPaginated({
|
|
int limit = 20,
|
|
int offset = 0,
|
|
String? customerName,
|
|
});
|
|
|
|
Future<int> getClosedTabCount({String? customerName});
|
|
|
|
Future<List<String>> getDistinctCustomerNames();
|
|
}
|
|
|
|
class DriftBarTabService implements BarTabService {
|
|
final AppDatabase database;
|
|
final _uuid = const Uuid();
|
|
|
|
DriftBarTabService({required this.database});
|
|
|
|
TabItem _mapItemRow(TabItemRow row) {
|
|
return TabItem(
|
|
id: row.id,
|
|
tabId: row.tabId,
|
|
productId: row.productId,
|
|
productName: row.productName,
|
|
quantity: row.quantity,
|
|
unitPriceInCents: row.unitPriceInCents,
|
|
);
|
|
}
|
|
|
|
BarTab _mapTabRow(BarTabRow row, List<TabItem> items) {
|
|
return BarTab(
|
|
id: row.id,
|
|
customerName: row.customerName,
|
|
status: row.status,
|
|
openedAt: row.openedAt,
|
|
closedAt: row.closedAt,
|
|
items: items,
|
|
);
|
|
}
|
|
|
|
ClosedTabItem _mapClosedItemRow(ClosedTabItemRow row) {
|
|
return ClosedTabItem(
|
|
id: row.id,
|
|
closedTabId: row.closedTabId,
|
|
productId: row.productId,
|
|
productName: row.productName,
|
|
quantity: row.quantity,
|
|
unitPriceInCents: row.unitPriceInCents,
|
|
);
|
|
}
|
|
|
|
Future<List<TabItem>> _getItemsForTab(String tabId) async {
|
|
final query = database.select(database.tabItems)
|
|
..where((item) => item.tabId.equals(tabId))
|
|
..orderBy([(item) => OrderingTerm.asc(item.createdAt)]);
|
|
|
|
final rows = await query.get();
|
|
|
|
return rows.map(_mapItemRow).toList();
|
|
}
|
|
|
|
Future<void> _decreaseProductStock(String productId, int amount) async {
|
|
if (amount <= 0) {
|
|
throw ArgumentError.value(amount, 'amount', 'Must be greater than zero');
|
|
}
|
|
|
|
final updatedRows = await database.customUpdate(
|
|
'UPDATE products '
|
|
'SET stock_quantity = stock_quantity - ? '
|
|
'WHERE id = ? AND stock_quantity >= ?',
|
|
variables: [
|
|
Variable.withInt(amount),
|
|
Variable.withString(productId),
|
|
Variable.withInt(amount),
|
|
],
|
|
updates: {database.products},
|
|
);
|
|
|
|
if (updatedRows == 1) return;
|
|
|
|
final product = await (database.select(
|
|
database.products,
|
|
)..where((row) => row.id.equals(productId))).getSingleOrNull();
|
|
|
|
if (product == null) {
|
|
throw Exception('Product not found');
|
|
}
|
|
|
|
throw const InsufficientStockException();
|
|
}
|
|
|
|
Future<void> _increaseProductStock(String productId, int amount) async {
|
|
if (amount <= 0) {
|
|
throw ArgumentError.value(amount, 'amount', 'Must be greater than zero');
|
|
}
|
|
|
|
final updatedRows = await database.customUpdate(
|
|
'UPDATE products '
|
|
'SET stock_quantity = stock_quantity + ? '
|
|
'WHERE id = ?',
|
|
variables: [Variable.withInt(amount), Variable.withString(productId)],
|
|
updates: {database.products},
|
|
);
|
|
|
|
if (updatedRows == 1) return;
|
|
|
|
throw Exception('Product not found');
|
|
}
|
|
|
|
@override
|
|
Future<List<BarTab>> getOpenTabs() async {
|
|
final query = database.select(database.barTabs)
|
|
..where((tab) => tab.status.equals('open'))
|
|
..orderBy([(tab) => OrderingTerm.desc(tab.openedAt)]);
|
|
|
|
final tabRows = await query.get();
|
|
|
|
final tabs = <BarTab>[];
|
|
|
|
for (final tabRow in tabRows) {
|
|
final items = await _getItemsForTab(tabRow.id);
|
|
|
|
tabs.add(_mapTabRow(tabRow, items));
|
|
}
|
|
|
|
return tabs;
|
|
}
|
|
|
|
@override
|
|
Future<BarTab?> getTabById(String id) async {
|
|
final query = database.select(database.barTabs)
|
|
..where((tab) => tab.id.equals(id));
|
|
|
|
final tabRow = await query.getSingleOrNull();
|
|
|
|
if (tabRow == null) {
|
|
return null;
|
|
}
|
|
|
|
final items = await _getItemsForTab(tabRow.id);
|
|
|
|
return _mapTabRow(tabRow, items);
|
|
}
|
|
|
|
@override
|
|
Future<BarTab> createTab({required String customerName}) async {
|
|
final id = _uuid.v4();
|
|
|
|
await database
|
|
.into(database.barTabs)
|
|
.insert(
|
|
BarTabsCompanion.insert(
|
|
id: id,
|
|
customerName: customerName,
|
|
status: const Value('open'),
|
|
openedAt: DateTime.now(),
|
|
),
|
|
);
|
|
|
|
final tab = await getTabById(id);
|
|
|
|
if (tab == null) {
|
|
throw Exception('Could not create tab.');
|
|
}
|
|
|
|
return tab;
|
|
}
|
|
|
|
@override
|
|
Future<void> addProductToTab({
|
|
required String tabId,
|
|
required Product product,
|
|
}) async {
|
|
await database.transaction(() async {
|
|
await _decreaseProductStock(product.id, 1);
|
|
|
|
final existingItemQuery = database.select(database.tabItems)
|
|
..where(
|
|
(item) =>
|
|
item.tabId.equals(tabId) & item.productId.equals(product.id),
|
|
);
|
|
|
|
final existingItem = await existingItemQuery.getSingleOrNull();
|
|
|
|
if (existingItem != null) {
|
|
final updateQuery = database.update(database.tabItems)
|
|
..where((item) => item.id.equals(existingItem.id));
|
|
|
|
await updateQuery.write(
|
|
TabItemsCompanion(quantity: Value(existingItem.quantity + 1)),
|
|
);
|
|
|
|
return;
|
|
}
|
|
|
|
await database
|
|
.into(database.tabItems)
|
|
.insert(
|
|
TabItemsCompanion.insert(
|
|
id: _uuid.v4(),
|
|
tabId: tabId,
|
|
productId: product.id,
|
|
productName: product.name,
|
|
quantity: 1,
|
|
unitPriceInCents: product.priceInCents,
|
|
createdAt: DateTime.now(),
|
|
),
|
|
);
|
|
});
|
|
}
|
|
|
|
@override
|
|
Future<int> adjustTabItemQuantity({
|
|
required String tabItemId,
|
|
required int delta,
|
|
}) async {
|
|
return database.transaction(() async {
|
|
final item = await (database.select(
|
|
database.tabItems,
|
|
)..where((row) => row.id.equals(tabItemId))).getSingleOrNull();
|
|
|
|
if (item == null || delta == 0) return 0;
|
|
|
|
final requestedQuantity = item.quantity + delta;
|
|
final actualDelta = requestedQuantity <= 0 ? -item.quantity : delta;
|
|
|
|
if (actualDelta > 0) {
|
|
await _decreaseProductStock(item.productId, actualDelta);
|
|
} else {
|
|
await _increaseProductStock(item.productId, -actualDelta);
|
|
}
|
|
|
|
if (requestedQuantity <= 0) {
|
|
final deletedRows = await (database.delete(
|
|
database.tabItems,
|
|
)..where((row) => row.id.equals(tabItemId))).go();
|
|
|
|
if (deletedRows != 1) {
|
|
throw StateError('Tab item was changed before it could be deleted');
|
|
}
|
|
} else {
|
|
final updatedRows =
|
|
await (database.update(database.tabItems)
|
|
..where((row) => row.id.equals(tabItemId)))
|
|
.write(TabItemsCompanion(quantity: Value(requestedQuantity)));
|
|
|
|
if (updatedRows != 1) {
|
|
throw StateError(
|
|
'Tab item was changed before its quantity was updated',
|
|
);
|
|
}
|
|
}
|
|
|
|
return actualDelta;
|
|
});
|
|
}
|
|
|
|
@override
|
|
Future<void> closeTab(
|
|
String tabId, {
|
|
PaymentMethod paymentMethod = PaymentMethod.cash,
|
|
}) async {
|
|
await database.transaction(() async {
|
|
final tabQuery = database.select(database.barTabs)
|
|
..where((tab) => tab.id.equals(tabId));
|
|
|
|
final tabRow = await tabQuery.getSingleOrNull();
|
|
|
|
if (tabRow == null) {
|
|
return;
|
|
}
|
|
|
|
final items = await _getItemsForTab(tabId);
|
|
|
|
if (items.isEmpty) {
|
|
return;
|
|
}
|
|
|
|
final closedTabId = _uuid.v4();
|
|
|
|
await database
|
|
.into(database.closedTabs)
|
|
.insert(
|
|
ClosedTabsCompanion.insert(
|
|
id: closedTabId,
|
|
originalTabId: tabId,
|
|
customerName: tabRow.customerName,
|
|
closedAt: DateTime.now(),
|
|
paymentMethod: Value(paymentMethod.value),
|
|
),
|
|
);
|
|
|
|
for (final item in items) {
|
|
await database
|
|
.into(database.closedTabItems)
|
|
.insert(
|
|
ClosedTabItemsCompanion.insert(
|
|
id: _uuid.v4(),
|
|
closedTabId: closedTabId,
|
|
productId: item.productId,
|
|
productName: item.productName,
|
|
quantity: item.quantity,
|
|
unitPriceInCents: item.unitPriceInCents,
|
|
),
|
|
);
|
|
}
|
|
|
|
final deleteQuery = database.delete(database.tabItems)
|
|
..where((item) => item.tabId.equals(tabId));
|
|
|
|
await deleteQuery.go();
|
|
});
|
|
}
|
|
|
|
@override
|
|
Future<List<ClosedTab>> getClosedTabs() async {
|
|
final count = await getClosedTabCount();
|
|
if (count == 0) return [];
|
|
|
|
return getClosedTabsPaginated(limit: count, offset: 0);
|
|
}
|
|
|
|
@override
|
|
Future<List<ClosedTab>> getClosedTabsPaginated({
|
|
int limit = 20,
|
|
int offset = 0,
|
|
String? customerName,
|
|
}) async {
|
|
var query = database.select(database.closedTabs)
|
|
..orderBy([(tab) => OrderingTerm.desc(tab.closedAt)])
|
|
..limit(limit, offset: offset);
|
|
|
|
if (customerName != null && customerName.isNotEmpty) {
|
|
query = query..where((tab) => tab.customerName.equals(customerName));
|
|
}
|
|
|
|
final closedTabRows = await query.get();
|
|
|
|
final closedTabs = <ClosedTab>[];
|
|
|
|
for (final row in closedTabRows) {
|
|
final itemsQuery = database.select(database.closedTabItems)
|
|
..where((item) => item.closedTabId.equals(row.id));
|
|
|
|
final itemRows = await itemsQuery.get();
|
|
|
|
closedTabs.add(
|
|
ClosedTab(
|
|
id: row.id,
|
|
originalTabId: row.originalTabId,
|
|
customerName: row.customerName,
|
|
closedAt: row.closedAt,
|
|
paymentMethod: PaymentMethod.fromValue(row.paymentMethod),
|
|
items: itemRows.map<ClosedTabItem>(_mapClosedItemRow).toList(),
|
|
),
|
|
);
|
|
}
|
|
|
|
return closedTabs;
|
|
}
|
|
|
|
@override
|
|
Future<int> getClosedTabCount({String? customerName}) async {
|
|
final countExpr = database.closedTabs.id.count();
|
|
|
|
var query = database.selectOnly(database.closedTabs)
|
|
..addColumns([countExpr]);
|
|
|
|
if (customerName != null && customerName.isNotEmpty) {
|
|
query = query
|
|
..where(database.closedTabs.customerName.equals(customerName));
|
|
}
|
|
|
|
final row = await query.getSingle();
|
|
return row.read(countExpr) ?? 0;
|
|
}
|
|
|
|
@override
|
|
Future<List<String>> getDistinctCustomerNames() async {
|
|
final rows = await database.select(database.closedTabs).get();
|
|
return rows.map((row) => row.customerName).toSet().toList()..sort();
|
|
}
|
|
}
|