317 lines
10 KiB
Dart
317 lines
10 KiB
Dart
import 'package:hub/shared/utils/cache_util.dart';
|
|
import 'package:sqflite/sqflite.dart';
|
|
import 'dart:developer';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:path/path.dart';
|
|
import 'package:sqflite/sqflite.dart';
|
|
import 'dart:developer';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:path/path.dart';
|
|
import 'package:sqflite/sqflite.dart';
|
|
|
|
class DatabaseConfig {
|
|
static const String dbName = 'database.db';
|
|
static const int dbVersion = 1;
|
|
|
|
static const String tableKeychain = 'keychain';
|
|
static const String columnKey = 'key';
|
|
static const String columnValue = 'value';
|
|
static const String columnType = 'type';
|
|
static const String columnUpdateAt = 'updateAt';
|
|
static const String columnResolvedAt = 'resolvedAt';
|
|
static const String columnCreatedAt = 'createdAt';
|
|
|
|
static const List<Map<String, dynamic>> initialData = [
|
|
{'key': 'devUUID', 'value': '', 'type': 'user'},
|
|
{'key': 'userUUID', 'value': '', 'type': 'user'},
|
|
{'key': 'userDevUUID', 'value': '', 'type': 'user'},
|
|
{'key': 'status', 'value': '', 'type': 'user'},
|
|
{'key': 'userName', 'value': '', 'type': 'user'},
|
|
{'key': 'cliUUID', 'value': '', 'type': 'local'},
|
|
{'key': 'ownerUUID', 'value': '', 'type': 'local'},
|
|
{'key': 'cliName', 'value': '', 'type': 'local'},
|
|
{'key': 'whatsapp', 'value': 'false', 'type': 'util'},
|
|
{'key': 'provisional', 'value': 'false', 'type': 'util'},
|
|
{'key': 'pets', 'value': 'false', 'type': 'util'},
|
|
{'key': 'local', 'value': 'false', 'type': 'util'},
|
|
{'key': 'notify', 'value': 'false', 'type': 'util'},
|
|
{'key': 'fingerprint', 'value': 'false', 'type': 'util'},
|
|
{'key': 'access', 'value': 'false', 'type': 'util'},
|
|
{'key': 'panic', 'value': 'false', 'type': 'util'},
|
|
{'key': 'person', 'value': 'false', 'type': 'util'},
|
|
{'key': 'requestOSnotification', 'value': 'false', 'type': 'util'},
|
|
{'key': 'petAmountRegister', 'value': '', 'type': 'local'},
|
|
];
|
|
}
|
|
|
|
class SQLiteStorageHelper {
|
|
static final SQLiteStorageHelper _instance = SQLiteStorageHelper._internal();
|
|
static Database? _database;
|
|
static String? _databasePath;
|
|
|
|
factory SQLiteStorageHelper() => _instance;
|
|
|
|
SQLiteStorageHelper._internal();
|
|
|
|
Future<Database> get database async {
|
|
if (_database != null) return _database!;
|
|
_database = await _initDatabase();
|
|
return _database!;
|
|
}
|
|
|
|
Future<String> _getDatabasePath() async {
|
|
if (_databasePath != null) return _databasePath!;
|
|
final databasesPath = await getDatabasesPath();
|
|
_databasePath = join(databasesPath, DatabaseConfig.dbName);
|
|
log('Database path: $_databasePath');
|
|
return _databasePath!;
|
|
}
|
|
|
|
Future<Database> _initDatabase() async {
|
|
final path = await _getDatabasePath();
|
|
return await openDatabase(
|
|
path,
|
|
version: DatabaseConfig.dbVersion,
|
|
onCreate: _onCreate,
|
|
onOpen: _onOpen,
|
|
onUpgrade: _onUpgrade,
|
|
onDowngrade: _onDowngrade,
|
|
onConfigure: _onConfigure,
|
|
).catchError((error) {
|
|
log('Error initializing database: $error');
|
|
throw error;
|
|
}).whenComplete(() async => await setupLocalVariables());
|
|
}
|
|
|
|
Future<void> _onCreate(Database db, int version) async {
|
|
log('Creating tables...');
|
|
await db.execute('''
|
|
CREATE TABLE ${DatabaseConfig.tableKeychain} (
|
|
${DatabaseConfig.columnKey} TEXT UNIQUE,
|
|
${DatabaseConfig.columnValue} TEXT,
|
|
${DatabaseConfig.columnType} TEXT,
|
|
${DatabaseConfig.columnUpdateAt} TEXT,
|
|
${DatabaseConfig.columnResolvedAt} TEXT,
|
|
${DatabaseConfig.columnCreatedAt} TEXT
|
|
);
|
|
''');
|
|
await _insertInitialData(db);
|
|
log('Tables created');
|
|
}
|
|
|
|
Future<void> _insertInitialData(Database db) async {
|
|
final batch = db.batch();
|
|
for (var data in DatabaseConfig.initialData) {
|
|
batch.insert(DatabaseConfig.tableKeychain, data);
|
|
}
|
|
await batch.commit(noResult: true);
|
|
}
|
|
|
|
Future<void> _onOpen(Database db) async {
|
|
log('Checking existing data...');
|
|
await _checkExistingData(db);
|
|
}
|
|
|
|
Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
|
|
log('Upgrading database from version $oldVersion to $newVersion');
|
|
}
|
|
|
|
Future<void> _onDowngrade(Database db, int oldVersion, int newVersion) async {
|
|
log('Downgrading database from version $oldVersion to $newVersion');
|
|
}
|
|
|
|
Future<void> _onConfigure(Database db) async {
|
|
log('Configuring database...');
|
|
}
|
|
|
|
Future<void> _checkExistingData(Database db) async {
|
|
try {
|
|
final maps = await db.query(DatabaseConfig.tableKeychain);
|
|
log('Existing data: $maps');
|
|
} catch (error) {
|
|
log('Error checking existing data: $error');
|
|
}
|
|
}
|
|
|
|
String _devUUID = '';
|
|
String _userUUID = '';
|
|
String _userDevUUID = '';
|
|
String _status = '';
|
|
String _userName = '';
|
|
String _cliUUID = '';
|
|
String _ownerUUID = '';
|
|
String _cliName = '';
|
|
String _petAmountRegister = '';
|
|
bool _whatsapp = false;
|
|
bool _provisional = false;
|
|
bool _pets = false;
|
|
bool _local = false;
|
|
bool _notify = false;
|
|
bool _fingerprint = false;
|
|
bool _access = false;
|
|
bool _panic = false;
|
|
bool _person = false;
|
|
bool _requestOSnotification = false;
|
|
|
|
String get createdAt => '0000-00-00 00:00:00';
|
|
String get devUUID => _devUUID;
|
|
String get userUUID => _userUUID;
|
|
String get userDevUUID => _userDevUUID;
|
|
String get status => _status;
|
|
String get userName => _userName;
|
|
String get cliUUID => _cliUUID;
|
|
String get ownerUUID => _ownerUUID;
|
|
String get cliName => _cliName;
|
|
String get petAmountRegister => _petAmountRegister;
|
|
bool get whatsapp => _whatsapp;
|
|
bool get provisional => _provisional;
|
|
bool get pets => _pets;
|
|
bool get local => _local;
|
|
bool get notify => _notify;
|
|
bool get fingerprint => _fingerprint;
|
|
bool get access => _access;
|
|
bool get panic => _panic;
|
|
bool get person => _person;
|
|
bool get requestOSnotification => _requestOSnotification;
|
|
|
|
set devUUID(String value) => set('devUUID', value);
|
|
set userUUID(String value) => set('userUUID', value);
|
|
set userDevUUID(String value) => set('userDevUUID', value);
|
|
set status(String value) => set('status', value);
|
|
set userName(String value) => set('userName', value);
|
|
set cliUUID(String value) => set('cliUUID', value);
|
|
set ownerUUID(String value) => set('ownerUUID', value);
|
|
set cliName(String value) => set('cliName', value);
|
|
set petAmountRegister(String value) => set('petAmountRegister', value);
|
|
set whatsapp(bool value) => set('whatsapp', value);
|
|
set provisional(bool value) => set('provisional', value);
|
|
set pets(bool value) => set('pets', value);
|
|
set local(bool value) => set('local', value);
|
|
set notify(bool value) => set('notify', value);
|
|
set fingerprint(bool value) => set('fingerprint', value);
|
|
set access(bool value) => set('access', value);
|
|
set panic(bool value) => set('panic', value);
|
|
set person(bool value) => set('person', value);
|
|
set requestOSnotification(bool value) => set('requestOSnotification', value);
|
|
|
|
Future<void> setupLocalVariables() async {
|
|
log('Setting up local variables...');
|
|
await _database?.transaction((txn) async {
|
|
final keys = [
|
|
'devUUID',
|
|
'userUUID',
|
|
'userDevUUID',
|
|
'status',
|
|
'userName',
|
|
'cliUUID',
|
|
'ownerUUID',
|
|
'cliName',
|
|
'whatsapp',
|
|
'provisional',
|
|
'pets',
|
|
'local',
|
|
'notify',
|
|
'fingerprint',
|
|
'access',
|
|
'panic',
|
|
'person',
|
|
'requestOSnotification'
|
|
];
|
|
|
|
final results = await Future.wait(keys.map((key) => get(key)));
|
|
|
|
_devUUID = results[0]?.toString() ?? '';
|
|
_userUUID = results[1]?.toString() ?? '';
|
|
_userDevUUID = results[2]?.toString() ?? '';
|
|
_status = results[3]?.toString() ?? '';
|
|
_userName = results[4]?.toString() ?? '';
|
|
_cliUUID = results[5]?.toString() ?? '';
|
|
_ownerUUID = results[6]?.toString() ?? '';
|
|
_cliName = results[7]?.toString() ?? '';
|
|
_whatsapp = results[8] == 'true';
|
|
_provisional = results[9] == 'true';
|
|
_pets = results[10] == 'true';
|
|
_local = results[11] == 'true';
|
|
_notify = results[12] == 'true';
|
|
_fingerprint = results[13] == 'true';
|
|
_access = results[14] == 'true';
|
|
_panic = results[15] == 'true';
|
|
_person = results[16] == 'true';
|
|
_requestOSnotification = results[17] == 'true';
|
|
});
|
|
}
|
|
|
|
Future<bool> getBoolean(String key) async {
|
|
final value = await get(key);
|
|
return value == 'true';
|
|
}
|
|
|
|
Future<dynamic> get(String key) async {
|
|
final cachedValue = CacheUtil.get(key);
|
|
if (cachedValue != null) {
|
|
return cachedValue;
|
|
}
|
|
|
|
try {
|
|
final db = await database;
|
|
final result = await db.query(
|
|
DatabaseConfig.tableKeychain,
|
|
columns: [DatabaseConfig.columnValue],
|
|
where: '${DatabaseConfig.columnKey} = ?',
|
|
whereArgs: [key],
|
|
);
|
|
|
|
if (result.isNotEmpty) {
|
|
final value = result.first[DatabaseConfig.columnValue];
|
|
CacheUtil.set(key, value);
|
|
return value;
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
log('Error getting value for key $key: $error');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<int> set(String key, dynamic value) async {
|
|
CacheUtil.set(key, value);
|
|
final db = await database;
|
|
final data = {
|
|
DatabaseConfig.columnKey: key,
|
|
DatabaseConfig.columnValue: value.toString(),
|
|
DatabaseConfig.columnUpdateAt: DateTime.now().toIso8601String(),
|
|
DatabaseConfig.columnCreatedAt: DateTime.now().toIso8601String(),
|
|
};
|
|
|
|
return await db.insert(
|
|
DatabaseConfig.tableKeychain,
|
|
data,
|
|
conflictAlgorithm: ConflictAlgorithm.replace,
|
|
);
|
|
}
|
|
|
|
Future<int> delete(String key) async {
|
|
final db = await database;
|
|
return await db.transaction((txn) async {
|
|
return await txn.delete(
|
|
DatabaseConfig.tableKeychain,
|
|
where: '${DatabaseConfig.columnKey} = ?',
|
|
whereArgs: [key],
|
|
);
|
|
});
|
|
}
|
|
|
|
Future<void> purge() async {
|
|
await deleteDatabaseDB();
|
|
await database;
|
|
log('Database purged');
|
|
}
|
|
|
|
Future<void> deleteDatabaseDB() async {
|
|
final path = await _getDatabasePath();
|
|
await deleteDatabase(path);
|
|
log('Database deleted');
|
|
_database = null;
|
|
}
|
|
}
|