298 lines
No EOL
10 KiB
Dart
298 lines
No EOL
10 KiB
Dart
import 'package:sqflite/sqflite.dart';
|
|
import 'package:path/path.dart';
|
|
import '../models/customer.dart';
|
|
import '../models/product.dart';
|
|
|
|
class DatabaseHelper {
|
|
static final DatabaseHelper instance = DatabaseHelper._init();
|
|
static Database? _database;
|
|
|
|
DatabaseHelper._init();
|
|
|
|
Future<Database> get database async {
|
|
if (_database != null) return _database!;
|
|
_database = await _initDB('customer_assist.db');
|
|
return _database!;
|
|
}
|
|
|
|
Future<Database> _initDB(String filePath) async {
|
|
final dbPath = await getDatabasesPath();
|
|
final path = join(dbPath, filePath);
|
|
return await openDatabase(
|
|
path,
|
|
version: 1,
|
|
onCreate: _createDB,
|
|
);
|
|
}
|
|
|
|
Future<void> _createDB(Database db, int version) async {
|
|
await db.execute('CREATE TABLE customers (id INTEGER PRIMARY KEY AUTOINCREMENT, customer_code TEXT NOT NULL, name TEXT NOT NULL, phone_number TEXT, email TEXT NOT NULL, address TEXT, sales_person_id INTEGER, tax_rate INTEGER DEFAULT 8, discount_rate INTEGER DEFAULT 0, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE employees (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, position TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE warehouses (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, description TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE suppliers (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, address TEXT, phone_number TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE products (id INTEGER PRIMARY KEY AUTOINCREMENT, product_code TEXT NOT NULL, name TEXT NOT NULL, unit_price INTEGER NOT NULL, quantity INTEGER DEFAULT 0, stock INTEGER DEFAULT 0, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE sales (id INTEGER PRIMARY KEY AUTOINCREMENT, customer_id INTEGER NOT NULL, sale_date TEXT NOT NULL, total_amount INTEGER NOT NULL, tax_rate INTEGER DEFAULT 8, product_items TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE estimates (id INTEGER PRIMARY KEY AUTOINCREMENT, customer_id INTEGER NOT NULL, estimate_number TEXT NOT NULL, product_items TEXT, total_amount INTEGER NOT NULL, tax_rate INTEGER DEFAULT 8, status TEXT DEFAULT "open", expiry_date TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
await db.execute('CREATE TABLE inventory (id INTEGER PRIMARY KEY AUTOINCREMENT, product_code TEXT UNIQUE NOT NULL, name TEXT NOT NULL, unit_price INTEGER NOT NULL, stock INTEGER DEFAULT 0, min_stock INTEGER DEFAULT 0, max_stock INTEGER DEFAULT 1000, supplier_name TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL)');
|
|
print('Database created with version: 1');
|
|
}
|
|
|
|
Future<int> insertCustomer(Customer customer) async {
|
|
final db = await database;
|
|
return await db.insert('customers', customer.toMap());
|
|
}
|
|
|
|
Future<Customer?> getCustomer(int id) async {
|
|
final db = await database;
|
|
final results = await db.query('customers', where: 'id = ?', whereArgs: [id]);
|
|
if (results.isEmpty) return null;
|
|
return Customer.fromMap(results.first);
|
|
}
|
|
|
|
Future<List<Customer>> getCustomers() async {
|
|
final db = await database;
|
|
final results = await db.query('customers');
|
|
return results.map((e) => Customer.fromMap(e)).toList();
|
|
}
|
|
|
|
Future<int> updateCustomer(Customer customer) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'customers',
|
|
customer.toMap(),
|
|
where: 'id = ?',
|
|
whereArgs: [customer.id],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteCustomer(int id) async {
|
|
final db = await database;
|
|
return await db.delete('customers', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertProduct(Product product) async {
|
|
final db = await database;
|
|
return await db.insert('products', product.toMap());
|
|
}
|
|
|
|
Future<Product?> getProduct(int id) async {
|
|
final db = await database;
|
|
final results = await db.query('products', where: 'id = ?', whereArgs: [id]);
|
|
if (results.isEmpty) return null;
|
|
return Product.fromMap(results.first);
|
|
}
|
|
|
|
Future<List<Product>> getProducts() async {
|
|
final db = await database;
|
|
final results = await db.query('products');
|
|
return results.map((e) => Product.fromMap(e)).toList();
|
|
}
|
|
|
|
Future<int> updateProduct(Product product) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'products',
|
|
product.toMap(),
|
|
where: 'id = ?',
|
|
whereArgs: [product.id],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteProduct(int id) async {
|
|
final db = await database;
|
|
return await db.delete('products', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
String encodeToJson(Object? data) {
|
|
try {
|
|
if (data == null) return '';
|
|
if (data is String) return data;
|
|
final json = StringBuffer('{');
|
|
var first = true;
|
|
if (data is Map) {
|
|
for (var key in data.keys) {
|
|
if (!first) json.write(',');
|
|
first = false;
|
|
json.write('"${key}":"${data[key]}"');
|
|
}
|
|
} else if (data is List) {
|
|
for (var item in data) {
|
|
if (!first) json.write(',');
|
|
first = false;
|
|
json.write('{"val":"$item"}');
|
|
}
|
|
}
|
|
json.write('}');
|
|
return json.toString();
|
|
} catch (e) {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
Future<int> insertSales(Map<String, dynamic> salesData) async {
|
|
final db = await database;
|
|
if (salesData['product_items'] != null && salesData['product_items'] is List) {
|
|
salesData['product_items'] = encodeToJson(salesData['product_items']);
|
|
}
|
|
return await db.insert('sales', salesData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getSales() async {
|
|
final db = await database;
|
|
return await db.query('sales');
|
|
}
|
|
|
|
Future<int> updateSales(Map<String, dynamic> salesData) async {
|
|
final db = await database;
|
|
if (salesData['product_items'] != null && salesData['product_items'] is List) {
|
|
salesData['product_items'] = encodeToJson(salesData['product_items']);
|
|
}
|
|
return await db.update(
|
|
'sales',
|
|
salesData,
|
|
where: 'id = ?',
|
|
whereArgs: [salesData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteSales(int id) async {
|
|
final db = await database;
|
|
return await db.delete('sales', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertEstimate(Map<String, dynamic> estimateData) async {
|
|
final db = await database;
|
|
if (estimateData['product_items'] != null && estimateData['product_items'] is List) {
|
|
estimateData['product_items'] = encodeToJson(estimateData['product_items']);
|
|
}
|
|
return await db.insert('estimates', estimateData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getEstimates() async {
|
|
final db = await database;
|
|
return await db.query('estimates');
|
|
}
|
|
|
|
Future<int> updateEstimate(Map<String, dynamic> estimateData) async {
|
|
final db = await database;
|
|
if (estimateData['product_items'] != null && estimateData['product_items'] is List) {
|
|
estimateData['product_items'] = encodeToJson(estimateData['product_items']);
|
|
}
|
|
return await db.update(
|
|
'estimates',
|
|
estimateData,
|
|
where: 'id = ?',
|
|
whereArgs: [estimateData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteEstimate(int id) async {
|
|
final db = await database;
|
|
return await db.delete('estimates', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertInventory(Map<String, dynamic> inventoryData) async {
|
|
final db = await database;
|
|
return await db.insert('inventory', inventoryData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getInventory() async {
|
|
final db = await database;
|
|
return await db.query('inventory');
|
|
}
|
|
|
|
Future<int> updateInventory(Map<String, dynamic> inventoryData) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'inventory',
|
|
inventoryData,
|
|
where: 'id = ?',
|
|
whereArgs: [inventoryData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteInventory(int id) async {
|
|
final db = await database;
|
|
return await db.delete('inventory', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertEmployee(Map<String, dynamic> employeeData) async {
|
|
final db = await database;
|
|
return await db.insert('employees', employeeData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getEmployees() async {
|
|
final db = await database;
|
|
return await db.query('employees');
|
|
}
|
|
|
|
Future<int> updateEmployee(Map<String, dynamic> employeeData) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'employees',
|
|
employeeData,
|
|
where: 'id = ?',
|
|
whereArgs: [employeeData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteEmployee(int id) async {
|
|
final db = await database;
|
|
return await db.delete('employees', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertWarehouse(Map<String, dynamic> warehouseData) async {
|
|
final db = await database;
|
|
return await db.insert('warehouses', warehouseData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getWarehouses() async {
|
|
final db = await database;
|
|
return await db.query('warehouses');
|
|
}
|
|
|
|
Future<int> updateWarehouse(Map<String, dynamic> warehouseData) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'warehouses',
|
|
warehouseData,
|
|
where: 'id = ?',
|
|
whereArgs: [warehouseData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteWarehouse(int id) async {
|
|
final db = await database;
|
|
return await db.delete('warehouses', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<int> insertSupplier(Map<String, dynamic> supplierData) async {
|
|
final db = await database;
|
|
return await db.insert('suppliers', supplierData);
|
|
}
|
|
|
|
Future<List<Map<String, dynamic>>> getSuppliers() async {
|
|
final db = await database;
|
|
return await db.query('suppliers');
|
|
}
|
|
|
|
Future<int> updateSupplier(Map<String, dynamic> supplierData) async {
|
|
final db = await database;
|
|
return await db.update(
|
|
'suppliers',
|
|
supplierData,
|
|
where: 'id = ?',
|
|
whereArgs: [supplierData['id'] as int],
|
|
);
|
|
}
|
|
|
|
Future<int> deleteSupplier(int id) async {
|
|
final db = await database;
|
|
return await db.delete('suppliers', where: 'id = ?', whereArgs: [id]);
|
|
}
|
|
|
|
Future<void> close() async {
|
|
final db = await database;
|
|
db.close();
|
|
}
|
|
} |