added local db
This commit is contained in:
367
lib/data/local/order_dao.dart
Normal file
367
lib/data/local/order_dao.dart
Normal file
@@ -0,0 +1,367 @@
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:sqflite/sqflite.dart';
|
||||
|
||||
import '../../domain/entities/cart.dart';
|
||||
import '../../domain/entities/customer.dart';
|
||||
import '../../domain/entities/product.dart';
|
||||
import '../../domain/entities/transaction.dart';
|
||||
import 'app_database.dart';
|
||||
import 'catalogue_dao.dart';
|
||||
|
||||
/// Persists bills.
|
||||
///
|
||||
/// Every completed sale lands here with `sync_status = 0`. The end-of-day
|
||||
/// upload selects those rows, sends them, and flips the accepted ones to 1.
|
||||
/// Nothing is ever deleted as part of syncing.
|
||||
class OrderDao {
|
||||
const OrderDao(this._db);
|
||||
|
||||
final Database _db;
|
||||
|
||||
static const int pending = 0;
|
||||
static const int synced = 1;
|
||||
|
||||
static String businessDateOf(DateTime dt) =>
|
||||
'${dt.year.toString().padLeft(4, '0')}-'
|
||||
'${dt.month.toString().padLeft(2, '0')}-'
|
||||
'${dt.day.toString().padLeft(2, '0')}';
|
||||
|
||||
// ----------------------------------------------------------------- Write
|
||||
/// Writes the bill and its lines atomically.
|
||||
Future<void> insertOrder(SaleTransaction t) async {
|
||||
final cart = t.cart;
|
||||
|
||||
await _db.transaction((txn) async {
|
||||
await txn.insert(
|
||||
Tables.orders,
|
||||
{
|
||||
'id': t.id,
|
||||
'invoice_number': t.invoiceNumber,
|
||||
'created_at': t.createdAt.millisecondsSinceEpoch,
|
||||
'business_date': businessDateOf(t.createdAt),
|
||||
'cashier_name': t.cashierName,
|
||||
'terminal_id': t.terminalId,
|
||||
'customer_id': cart.customer?.id,
|
||||
'customer_mobile': cart.customer?.mobile,
|
||||
'customer_name': cart.customer?.name,
|
||||
'subtotal': cart.subtotal,
|
||||
'line_discount': cart.lineDiscountTotal,
|
||||
'bill_discount': cart.billDiscountTotal,
|
||||
'loyalty_value': cart.loyaltyRedemptionValue,
|
||||
'taxable_amount': cart.taxableAmount,
|
||||
'tax_amount': cart.taxAmount,
|
||||
'round_off': cart.roundOff,
|
||||
'total': t.total,
|
||||
'points_earned': cart.pointsEarned,
|
||||
'points_redeemed': cart.pointsRedeemed,
|
||||
'payments_json': jsonEncode([
|
||||
for (final p in t.payments)
|
||||
{
|
||||
'method': p.method.name,
|
||||
'amount': p.amount,
|
||||
'tendered': p.tendered,
|
||||
'reference': p.reference,
|
||||
},
|
||||
]),
|
||||
'status': t.status.name,
|
||||
'sync_status': pending,
|
||||
'sync_attempts': 0,
|
||||
},
|
||||
conflictAlgorithm: ConflictAlgorithm.replace,
|
||||
);
|
||||
|
||||
final batch = txn.batch();
|
||||
for (final line in cart.lines) {
|
||||
batch.insert(Tables.orderItems, {
|
||||
'order_id': t.id,
|
||||
'product_id': line.product.id,
|
||||
'name': line.product.name,
|
||||
'barcode': line.product.barcode,
|
||||
'sku': line.product.sku,
|
||||
'unit': line.product.unit.name,
|
||||
'unit_price': line.product.price,
|
||||
'quantity': line.quantity,
|
||||
'discount': line.discountAmount,
|
||||
'gst_rate': line.product.gstRate,
|
||||
'tax_amount': line.taxAmount,
|
||||
'line_total': line.payable,
|
||||
});
|
||||
}
|
||||
await batch.commit(noResult: true);
|
||||
});
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ Read
|
||||
Future<List<SaleTransaction>> recent({int limit = 100}) =>
|
||||
_query(orderBy: 'created_at DESC', limit: limit);
|
||||
|
||||
Future<List<SaleTransaction>> forBusinessDate(DateTime day) =>
|
||||
_query(where: 'business_date = ?', whereArgs: [businessDateOf(day)]);
|
||||
|
||||
/// The end-of-day upload set.
|
||||
Future<List<SaleTransaction>> unsynced({int limit = 500}) => _query(
|
||||
where: 'sync_status = ?',
|
||||
whereArgs: [pending],
|
||||
orderBy: 'created_at ASC',
|
||||
limit: limit,
|
||||
);
|
||||
|
||||
Future<SaleTransaction?> byInvoice(String invoiceNumber) async {
|
||||
final rows = await _query(
|
||||
where: 'invoice_number = ?',
|
||||
whereArgs: [invoiceNumber],
|
||||
limit: 1,
|
||||
);
|
||||
return rows.isEmpty ? null : rows.first;
|
||||
}
|
||||
|
||||
Future<int> unsyncedCount() async {
|
||||
final r = await _db.rawQuery(
|
||||
'SELECT COUNT(*) AS c FROM ${Tables.orders} WHERE sync_status = ?',
|
||||
[pending],
|
||||
);
|
||||
return r.first['c']! as int;
|
||||
}
|
||||
|
||||
Future<double> salesTotalForDay(DateTime day) async {
|
||||
final r = await _db.rawQuery(
|
||||
'SELECT COALESCE(SUM(total), 0) AS t FROM ${Tables.orders} '
|
||||
"WHERE business_date = ? AND status = 'completed'",
|
||||
[businessDateOf(day)],
|
||||
);
|
||||
return (r.first['t']! as num).toDouble();
|
||||
}
|
||||
|
||||
/// Sync state of an order, for display in the events log.
|
||||
Future<Map<String, Object?>?> syncRow(String orderId) async {
|
||||
final rows = await _db.query(
|
||||
Tables.orders,
|
||||
columns: [
|
||||
'id',
|
||||
'invoice_number',
|
||||
'total',
|
||||
'created_at',
|
||||
'sync_status',
|
||||
'synced_at',
|
||||
'sync_attempts',
|
||||
'sync_error',
|
||||
],
|
||||
where: 'id = ?',
|
||||
whereArgs: [orderId],
|
||||
limit: 1,
|
||||
);
|
||||
return rows.isEmpty ? null : rows.first;
|
||||
}
|
||||
|
||||
Future<List<Map<String, Object?>>> syncRows({int limit = 200}) => _db.query(
|
||||
Tables.orders,
|
||||
columns: [
|
||||
'id',
|
||||
'invoice_number',
|
||||
'total',
|
||||
'created_at',
|
||||
'sync_status',
|
||||
'synced_at',
|
||||
'sync_attempts',
|
||||
'sync_error',
|
||||
],
|
||||
orderBy: 'created_at DESC',
|
||||
limit: limit,
|
||||
);
|
||||
|
||||
// ----------------------------------------------------------------- Sync
|
||||
/// Flips accepted orders to `sync_status = 1`.
|
||||
Future<void> markSynced(List<String> orderIds) async {
|
||||
if (orderIds.isEmpty) return;
|
||||
final now = DateTime.now().millisecondsSinceEpoch;
|
||||
final placeholders = List.filled(orderIds.length, '?').join(',');
|
||||
|
||||
await _db.rawUpdate(
|
||||
'UPDATE ${Tables.orders} SET sync_status = ?, synced_at = ?, '
|
||||
'sync_error = NULL WHERE id IN ($placeholders)',
|
||||
[synced, now, ...orderIds],
|
||||
);
|
||||
}
|
||||
|
||||
/// Records a failed attempt. The rows stay at `sync_status = 0`.
|
||||
Future<void> markFailed(List<String> orderIds, String error) async {
|
||||
if (orderIds.isEmpty) return;
|
||||
final placeholders = List.filled(orderIds.length, '?').join(',');
|
||||
|
||||
await _db.rawUpdate(
|
||||
'UPDATE ${Tables.orders} SET sync_attempts = sync_attempts + 1, '
|
||||
'sync_error = ? WHERE id IN ($placeholders)',
|
||||
[error, ...orderIds],
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------- Parked bills
|
||||
Future<void> park(ParkedBill bill) async {
|
||||
await _db.insert(
|
||||
Tables.parkedBills,
|
||||
{
|
||||
'id': bill.id,
|
||||
'label': bill.label,
|
||||
'parked_at': bill.parkedAt.millisecondsSinceEpoch,
|
||||
'cart_json': jsonEncode(_cartToJson(bill.cart)),
|
||||
},
|
||||
conflictAlgorithm: ConflictAlgorithm.replace,
|
||||
);
|
||||
}
|
||||
|
||||
Future<List<ParkedBill>> parkedBills() async {
|
||||
final rows =
|
||||
await _db.query(Tables.parkedBills, orderBy: 'parked_at DESC');
|
||||
return rows
|
||||
.map((r) => ParkedBill(
|
||||
id: r['id']! as String,
|
||||
label: r['label'] as String?,
|
||||
parkedAt:
|
||||
DateTime.fromMillisecondsSinceEpoch(r['parked_at']! as int),
|
||||
cart: _cartFromJson(
|
||||
jsonDecode(r['cart_json']! as String) as Map<String, Object?>,
|
||||
),
|
||||
))
|
||||
.toList();
|
||||
}
|
||||
|
||||
Future<void> removeParked(String id) async {
|
||||
await _db.delete(Tables.parkedBills, where: 'id = ?', whereArgs: [id]);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------- Internals
|
||||
Future<List<SaleTransaction>> _query({
|
||||
String? where,
|
||||
List<Object?>? whereArgs,
|
||||
String orderBy = 'created_at DESC',
|
||||
int? limit,
|
||||
}) async {
|
||||
final orders = await _db.query(
|
||||
Tables.orders,
|
||||
where: where,
|
||||
whereArgs: whereArgs,
|
||||
orderBy: orderBy,
|
||||
limit: limit,
|
||||
);
|
||||
if (orders.isEmpty) return const [];
|
||||
|
||||
final ids = orders.map((o) => o['id']! as String).toList();
|
||||
final placeholders = List.filled(ids.length, '?').join(',');
|
||||
final items = await _db.query(
|
||||
Tables.orderItems,
|
||||
where: 'order_id IN ($placeholders)',
|
||||
whereArgs: ids,
|
||||
);
|
||||
|
||||
final byOrder = <String, List<Map<String, Object?>>>{};
|
||||
for (final i in items) {
|
||||
byOrder.putIfAbsent(i['order_id']! as String, () => []).add(i);
|
||||
}
|
||||
|
||||
return orders
|
||||
.map((o) => _transactionFromRows(o, byOrder[o['id']] ?? const []))
|
||||
.toList();
|
||||
}
|
||||
|
||||
SaleTransaction _transactionFromRows(
|
||||
Map<String, Object?> o,
|
||||
List<Map<String, Object?>> items,
|
||||
) {
|
||||
// Lines are rebuilt from the snapshot taken at sale time, not from the
|
||||
// current catalogue, so a reprint always shows what was actually charged.
|
||||
final lines = items.map((i) {
|
||||
final product = Product(
|
||||
id: i['product_id']! as String,
|
||||
name: i['name']! as String,
|
||||
barcode: i['barcode']! as String,
|
||||
sku: i['sku']! as String,
|
||||
category: ProductCategory.grocery,
|
||||
price: (i['unit_price']! as num).toDouble(),
|
||||
stock: 0,
|
||||
unit: UnitOfMeasure.values.byName(i['unit']! as String),
|
||||
gstRate: (i['gst_rate']! as num).toDouble(),
|
||||
);
|
||||
return CartLine(
|
||||
product: product,
|
||||
quantity: (i['quantity']! as num).toDouble(),
|
||||
discount: (i['discount']! as num) > 0
|
||||
? Discount(
|
||||
type: DiscountType.flat,
|
||||
value: (i['discount']! as num).toDouble(),
|
||||
)
|
||||
: Discount.none,
|
||||
);
|
||||
}).toList();
|
||||
|
||||
final customerId = o['customer_id'] as String?;
|
||||
final customer = customerId == null
|
||||
? null
|
||||
: Customer(
|
||||
id: customerId,
|
||||
name: (o['customer_name'] as String?) ?? 'Customer',
|
||||
mobile: (o['customer_mobile'] as String?) ?? '',
|
||||
);
|
||||
|
||||
final payments = (jsonDecode(o['payments_json']! as String) as List)
|
||||
.cast<Map<String, Object?>>()
|
||||
.map((p) => PaymentSplit(
|
||||
method: PaymentMethod.values.byName(p['method']! as String),
|
||||
amount: (p['amount']! as num).toDouble(),
|
||||
tendered: (p['tendered'] as num?)?.toDouble(),
|
||||
reference: p['reference'] as String?,
|
||||
))
|
||||
.toList();
|
||||
|
||||
return SaleTransaction(
|
||||
id: o['id']! as String,
|
||||
invoiceNumber: o['invoice_number']! as String,
|
||||
cart: Cart(lines: lines, customer: customer),
|
||||
payments: payments,
|
||||
createdAt: DateTime.fromMillisecondsSinceEpoch(o['created_at']! as int),
|
||||
cashierName: o['cashier_name']! as String,
|
||||
terminalId: o['terminal_id']! as String,
|
||||
status: TransactionStatus.values.byName(o['status']! as String),
|
||||
);
|
||||
}
|
||||
|
||||
Map<String, Object?> _cartToJson(Cart cart) => {
|
||||
'customer': cart.customer == null
|
||||
? null
|
||||
: CatalogueDao.customerToRow(cart.customer!),
|
||||
'points_redeemed': cart.pointsRedeemed,
|
||||
'note': cart.note,
|
||||
'lines': [
|
||||
for (final l in cart.lines)
|
||||
{
|
||||
'product': CatalogueDao.productToRow(l.product),
|
||||
'quantity': l.quantity,
|
||||
'discount_type': l.discount.type.name,
|
||||
'discount_value': l.discount.value,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
Cart _cartFromJson(Map<String, Object?> j) {
|
||||
final customerRow = j['customer'] as Map<String, Object?>?;
|
||||
return Cart(
|
||||
customer: customerRow == null
|
||||
? null
|
||||
: CatalogueDao.customerFromRow(customerRow),
|
||||
pointsRedeemed: (j['points_redeemed'] as int?) ?? 0,
|
||||
note: j['note'] as String?,
|
||||
lines: (j['lines'] as List).cast<Map<String, Object?>>().map((l) {
|
||||
return CartLine(
|
||||
product: CatalogueDao.productFromRow(
|
||||
l['product']! as Map<String, Object?>,
|
||||
),
|
||||
quantity: (l['quantity']! as num).toDouble(),
|
||||
discount: Discount(
|
||||
type: DiscountType.values.byName(l['discount_type']! as String),
|
||||
value: (l['discount_value']! as num).toDouble(),
|
||||
),
|
||||
);
|
||||
}).toList(),
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user