jantunesmessias
/
flutter-freaccess-hub
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP

This commit is contained in:
J. A. Messias 2024-09-19 13:46:44 -03:00
parent 1050c6caae
commit 392c5980ff
2 changed files with 111 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/main.dart
View File

@ -23,6 +23,7 @@ final GlobalKey<NavigatorState> navigatorKey = GlobalKey<NavigatorState>();
Future<void> initializeApp() async {
WidgetsFlutterBinding.ensureInitialized();
DatabaseHelper().deleteDatabaseDB();
await DatabaseHelper().database;
final status = await AppTrackingTransparency.requestTrackingAuthorization();

212
lib/shared/helpers/db_helper.dart
View File

@ -1,10 +1,21 @@
import 'dart:developer';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.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';
}
class DatabaseHelper {
static final DatabaseHelper _instance = DatabaseHelper._internal();
static Database? _database;
@ -19,28 +30,12 @@ class DatabaseHelper {
return _database!;
}
Future<void> _onUpgrade(Database db, int oldVersion, int newVersion) async {
log('Upgrading database from version $oldVersion to $newVersion');
// if (oldVersion < 2) {
// // await db.execute('ALTER TABLE keychain ADD COLUMN newColumn TEXT');
// }
}
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<Database> _initDatabase() async {
final path = await _getDatabasePath();
log('Database path: $path');
return await openDatabase(
path,
version: 1,
version: DatabaseConfig.dbVersion,
onCreate: _onCreate,
onOpen: _onOpen,
onUpgrade: _onUpgrade,
@ -51,50 +46,83 @@ class DatabaseHelper {
}).whenComplete(() => log('Database initialized'));
}
Future<String> _getDatabasePath() async {
final databasesPath = await getDatabasesPath();
final path = join(databasesPath, DatabaseConfig.dbName);
log('Database path: $path');
return path;
}
Future<void> _onCreate(Database db, int version) async {
log('Creating tables...');
await db.execute('''
CREATE TABLE keychain (
key TEXT,
value TEXT,
type TEXT,
updateAt TEXT,
resolvedAt TEXT,
createdAt TEXT
);
''');
// ----------------------------------------------
insert('devUUID', '', 'user');
insert('userUUID', '', 'user');
insert('userDevUUID', '', 'user');
insert('status', '', 'user');
insert('userName', '', 'user');
// ----------------------------------------------
insert('cliUUID', '', 'local');
insert('ownerUUID', '', 'local');
insert('cliName', '', 'local');
// ----------------------------------------------
insert('whatsapp', 'false', 'util');
insert('provisional', 'false', 'util');
insert('pets', 'false', 'util');
insert('local', 'false', 'util');
insert('notify', 'false', 'util');
insert('fingerprint', 'false', 'util');
insert('access', 'false', 'util');
insert('panic', 'false', 'util');
insert('person', 'false', 'util');
insert('requestOSnotification', 'false', 'util');
insert('petAmountRegister', '', 'local');
// ----------------------------------------------
CREATE TABLE ${DatabaseConfig.tableKeychain} (
${DatabaseConfig.columnKey} TEXT,
${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 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'},
];
for (var data in initialData) {
await db.insert(DatabaseConfig.tableKeychain, data);
}
}
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');
}
}
Future<void> deleteDatabaseDB() async {
final path = await _getDatabasePath();
await deleteDatabase(path);
@ -102,50 +130,33 @@ class DatabaseHelper {
_database = null;
}
Future<String> _getDatabasePath() async {
final databasesPath = await getDatabasesPath();
final path = join(databasesPath, 'database.db');
log('Database path: $path');
return path;
}
Future<void> _checkExistingData(Database db) async {
try {
final maps = await db.query('keychain');
log('Existing data: $maps');
} catch (error) {
log('Error checking existing data: $error');
}
}
Future<dynamic> get({String? key, String? field}) async {
try {
final db = await database;
List<Map<String, dynamic>> queryResult;
if (field != null && key != null) {
queryResult = await db.query(
'keychain',
DatabaseConfig.tableKeychain,
columns: [field],
where: 'key = ?',
where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key],
);
} else if (field != null) {
queryResult = await db.query(
'keychain',
DatabaseConfig.tableKeychain,
columns: [field],
);
} else if (key != null) {
field = 'value';
field = DatabaseConfig.columnValue;
queryResult = await db.query(
'keychain',
DatabaseConfig.tableKeychain,
columns: [field],
where: 'key = ?',
where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key],
);
} else {
queryResult = await db.query('keychain');
queryResult = await db.query(DatabaseConfig.tableKeychain);
}
log('Query result for key: $key, field: $field -> $queryResult');
@ -165,35 +176,35 @@ class DatabaseHelper {
final db = await database;
final Map<String, dynamic> data = {
'key': key,
'value': value.toString(),
'type': type,
'updateAt': DateTime.now().toIso8601String(),
'resolvedAt': null,
'createdAt': DateTime.now().toIso8601String(),
DatabaseConfig.columnKey: key,
DatabaseConfig.columnValue: value.toString(),
DatabaseConfig.columnType: type,
DatabaseConfig.columnUpdateAt: DateTime.now().toIso8601String(),
DatabaseConfig.columnResolvedAt: null,
DatabaseConfig.columnCreatedAt: DateTime.now().toIso8601String(),
};
log('Inserting: $data');
return await db.insert('keychain', data);
return await db.insert(DatabaseConfig.tableKeychain, data);
}
Future<int> update(String key, dynamic value, String? type) async {
final db = await database;
final Map<String, dynamic> data = {
'key': key,
if (value != null) 'value': value.toString(),
if (type != null) 'type': type,
'updateAt': DateTime.now().toIso8601String(),
'resolvedAt': null,
'createdAt': DateTime.now().toIso8601String(),
DatabaseConfig.columnKey: key,
if (value != null) DatabaseConfig.columnValue: value.toString(),
if (type != null) DatabaseConfig.columnType: type,
DatabaseConfig.columnUpdateAt: DateTime.now().toIso8601String(),
DatabaseConfig.columnResolvedAt: null,
DatabaseConfig.columnCreatedAt: DateTime.now().toIso8601String(),
};
log('Updating: $data');
return await db.update(
'keychain',
DatabaseConfig.tableKeychain,
data,
where: 'key = ?',
where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key],
);
}
@ -203,9 +214,9 @@ class DatabaseHelper {
log('Setting value of key: $key to empty string');
return await db.update(
'keychain',
{'value': ''},
where: 'key = ?',
DatabaseConfig.tableKeychain,
{DatabaseConfig.columnValue: ''},
where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key],
);
}
@ -215,18 +226,15 @@ class DatabaseHelper {
log('Deleting key: $key');
return await db.delete(
'keychain',
where: 'key = ?',
DatabaseConfig.tableKeychain,
where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key],
);
}
Future<void> purge() async {
final DatabaseHelper helper = DatabaseHelper();
await helper.deleteDatabaseDB();
await helper.database;
await deleteDatabaseDB();
await database;
log('Purge');
}
}