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 { Future<void> initializeApp() async {
WidgetsFlutterBinding.ensureInitialized(); WidgetsFlutterBinding.ensureInitialized();
DatabaseHelper().deleteDatabaseDB();
await DatabaseHelper().database; await DatabaseHelper().database;
final status = await AppTrackingTransparency.requestTrackingAuthorization(); final status = await AppTrackingTransparency.requestTrackingAuthorization();

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

@ -1,10 +1,21 @@
import 'dart:developer'; import 'dart:developer';
import 'package:flutter/foundation.dart'; import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:path/path.dart'; import 'package:path/path.dart';
import 'package:sqflite/sqflite.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 { class DatabaseHelper {
static final DatabaseHelper _instance = DatabaseHelper._internal(); static final DatabaseHelper _instance = DatabaseHelper._internal();
static Database? _database; static Database? _database;
@ -19,28 +30,12 @@ class DatabaseHelper {
return _database!; 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 { Future<Database> _initDatabase() async {
final path = await _getDatabasePath(); final path = await _getDatabasePath();
log('Database path: $path'); log('Database path: $path');
return await openDatabase( return await openDatabase(
path, path,
version: 1, version: DatabaseConfig.dbVersion,
onCreate: _onCreate, onCreate: _onCreate,
onOpen: _onOpen, onOpen: _onOpen,
onUpgrade: _onUpgrade, onUpgrade: _onUpgrade,
@ -51,50 +46,83 @@ class DatabaseHelper {
}).whenComplete(() => log('Database initialized')); }).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 { Future<void> _onCreate(Database db, int version) async {
log('Creating tables...'); log('Creating tables...');
await db.execute(''' await db.execute('''
CREATE TABLE keychain ( CREATE TABLE ${DatabaseConfig.tableKeychain} (
key TEXT, ${DatabaseConfig.columnKey} TEXT,
value TEXT, ${DatabaseConfig.columnValue} TEXT,
type TEXT, ${DatabaseConfig.columnType} TEXT,
updateAt TEXT, ${DatabaseConfig.columnUpdateAt} TEXT,
resolvedAt TEXT, ${DatabaseConfig.columnResolvedAt} TEXT,
createdAt TEXT ${DatabaseConfig.columnCreatedAt} TEXT
); );
'''); ''');
// ---------------------------------------------- await _insertInitialData(db);
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');
// ----------------------------------------------
log('Tables created'); 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 { Future<void> _onOpen(Database db) async {
log('Checking existing data...'); log('Checking existing data...');
await _checkExistingData(db); 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 { Future<void> deleteDatabaseDB() async {
final path = await _getDatabasePath(); final path = await _getDatabasePath();
await deleteDatabase(path); await deleteDatabase(path);
@ -102,50 +130,33 @@ class DatabaseHelper {
_database = null; _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 { Future<dynamic> get({String? key, String? field}) async {
try { try {
final db = await database; final db = await database;
List<Map<String, dynamic>> queryResult; List<Map<String, dynamic>> queryResult;
if (field != null && key != null) { if (field != null && key != null) {
queryResult = await db.query( queryResult = await db.query(
'keychain', DatabaseConfig.tableKeychain,
columns: [field], columns: [field],
where: 'key = ?', where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key], whereArgs: [key],
); );
} else if (field != null) { } else if (field != null) {
queryResult = await db.query( queryResult = await db.query(
'keychain', DatabaseConfig.tableKeychain,
columns: [field], columns: [field],
); );
} else if (key != null) { } else if (key != null) {
field = 'value'; field = DatabaseConfig.columnValue;
queryResult = await db.query( queryResult = await db.query(
'keychain', DatabaseConfig.tableKeychain,
columns: [field], columns: [field],
where: 'key = ?', where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key], whereArgs: [key],
); );
} else { } else {
queryResult = await db.query('keychain'); queryResult = await db.query(DatabaseConfig.tableKeychain);
} }
log('Query result for key: $key, field: $field -> $queryResult'); log('Query result for key: $key, field: $field -> $queryResult');
@ -165,35 +176,35 @@ class DatabaseHelper {
final db = await database; final db = await database;
final Map<String, dynamic> data = { final Map<String, dynamic> data = {
'key': key, DatabaseConfig.columnKey: key,
'value': value.toString(), DatabaseConfig.columnValue: value.toString(),
'type': type, DatabaseConfig.columnType: type,
'updateAt': DateTime.now().toIso8601String(), DatabaseConfig.columnUpdateAt: DateTime.now().toIso8601String(),
'resolvedAt': null, DatabaseConfig.columnResolvedAt: null,
'createdAt': DateTime.now().toIso8601String(), DatabaseConfig.columnCreatedAt: DateTime.now().toIso8601String(),
}; };
log('Inserting: $data'); 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 { Future<int> update(String key, dynamic value, String? type) async {
final db = await database; final db = await database;
final Map<String, dynamic> data = { final Map<String, dynamic> data = {
'key': key, DatabaseConfig.columnKey: key,
if (value != null) 'value': value.toString(), if (value != null) DatabaseConfig.columnValue: value.toString(),
if (type != null) 'type': type, if (type != null) DatabaseConfig.columnType: type,
'updateAt': DateTime.now().toIso8601String(), DatabaseConfig.columnUpdateAt: DateTime.now().toIso8601String(),
'resolvedAt': null, DatabaseConfig.columnResolvedAt: null,
'createdAt': DateTime.now().toIso8601String(), DatabaseConfig.columnCreatedAt: DateTime.now().toIso8601String(),
}; };
log('Updating: $data'); log('Updating: $data');
return await db.update( return await db.update(
'keychain', DatabaseConfig.tableKeychain,
data, data,
where: 'key = ?', where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key], whereArgs: [key],
); );
} }
@ -203,9 +214,9 @@ class DatabaseHelper {
log('Setting value of key: $key to empty string'); log('Setting value of key: $key to empty string');
return await db.update( return await db.update(
'keychain', DatabaseConfig.tableKeychain,
{'value': ''}, {DatabaseConfig.columnValue: ''},
where: 'key = ?', where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key], whereArgs: [key],
); );
} }
@ -215,18 +226,15 @@ class DatabaseHelper {
log('Deleting key: $key'); log('Deleting key: $key');
return await db.delete( return await db.delete(
'keychain', DatabaseConfig.tableKeychain,
where: 'key = ?', where: '${DatabaseConfig.columnKey} = ?',
whereArgs: [key], whereArgs: [key],
); );
} }
Future<void> purge() async { Future<void> purge() async {
final DatabaseHelper helper = DatabaseHelper(); await deleteDatabaseDB();
await database;
await helper.deleteDatabaseDB();
await helper.database;
log('Purge'); log('Purge');
} }
} }