refactor(repository): add environment prefix key

lib/models/server.dart

@@ -29,7 +29,7 @@ class Server {
   /// Basic authentication password (Use only v5)
   final String? basicAuthPassword;
 
-  /// Session manager (Use only v5)
+  /// Session manager (Use only v6)
   final SessionManager sm;
 
   Server({
@@ -42,7 +42,7 @@ class Server {
     this.basicAuthUser,
     this.basicAuthPassword,
     SessionManager? sm,
-  }) : sm = sm ?? SessionManager(SecureStorageRepository(), address);
+  }) : sm = sm ?? SessionManager(SecureStorageRepository(address: address));
 
   Server copyWith({
     String? address,

lib/repository/database.dart

@@ -143,22 +143,18 @@
         });
 
         // Load sensitive data from secure storage
-        final passCode = await _secureStorage.getValue('passCode');
+        final passCode = await _secureStorage.passCode;
         appConfig = AppDbData.withSecrets(appConfig!, passCode);
 
-        // _secureStorage.readAll()
-        logger.d((await _secureStorage.readAll()).toString());
+        logger.d((await _secureStorage.readEnvironmentData()).toString());
 
         if (servers != null && servers!.isNotEmpty) {
           for (int i = 0; i < servers!.length; i++) {
             final server = servers![i];
-            final token =
-                await _secureStorage.getValue('${server.address}_token');
-            final basicAuthUser = await _secureStorage
-                .getValue('${server.address}_basicAuthUser');
-            final basicAuthPassword = await _secureStorage
-                .getValue('${server.address}_basicAuthPassword');
-            final sid = await _secureStorage.getValue('${server.address}_sid');
+            final token = await _secureStorage.token;
+            final basicAuthUser = await _secureStorage.basicAuthUser;
+            final basicAuthPassword = await _secureStorage.basicAuthPassword;
+            final sid = await _secureStorage.sid;
 
             servers![i] = ServerDbData.withSecrets(
               server,
@@ -210,33 +206,21 @@
   Future<bool?> saveServerQuery(Server server) async {
     try {
       if (server.token != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_token',
-          server.token!,
-        );
+        await _secureStorage.saveToken(server.token);
       }
       if (server.basicAuthUser != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_basicAuthUser',
-          server.basicAuthUser!,
-        );
+        await _secureStorage.saveBasicAuthUser(server.basicAuthUser);
       }
       if (server.basicAuthPassword != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_basicAuthPassword',
-          server.basicAuthPassword!,
-        );
+        await _secureStorage.saveBasicAuthPassword(server.basicAuthPassword);
       }
 
       final password = await server.sm.password;
       if (password != null) {
-        await _secureStorage.saveValue('${server.address}_password', password);
+        await _secureStorage.savePassword(password);
       }
       if (server.sm.sid != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_sid',
-          server.sm.sid ?? '',
-        );
+        await _secureStorage.saveSid(server.sm.sid);
       }
 
       await _dbInstance.transaction((txn) async {
@@ -278,29 +262,20 @@
   Future<bool> editServerQuery(Server server) async {
     try {
       if (server.token != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_token',
-          server.token!,
-        );
+        await _secureStorage.saveToken(server.token);
       }
       if (server.basicAuthUser != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_basicAuthUser',
-          server.basicAuthUser!,
-        );
+        await _secureStorage.saveBasicAuthUser(server.basicAuthUser);
       }
       if (server.basicAuthPassword != null) {
-        await _secureStorage.saveValue(
-          '${server.address}_basicAuthPassword',
-          server.basicAuthPassword!,
-        );
+        await _secureStorage.saveBasicAuthPassword(server.basicAuthPassword);
       }
       final password = await server.sm.password;
       if (password != null) {
-        await _secureStorage.saveValue('${server.address}_password', password);
+        await _secureStorage.savePassword(password);
       }
       if (server.sm.sid != null) {
-        await _secureStorage.saveValue('${server.address}_sid', server.sm.sid!);
+        await _secureStorage.saveSid(server.sm.sid);
       }
 
       return await _dbInstance.transaction((txn) async {
@@ -412,12 +387,12 @@
   ///   `false` if it fails.
   Future<bool> removeServerQuery(String address) async {
     try {
-      await _secureStorage.deleteValue('${address}_token');
-      await _secureStorage.deleteValue('${address}_basicAuthUser');
-      await _secureStorage.deleteValue('${address}_basicAuthPassword');
-      await _secureStorage.deleteValue('${address}_password');
-      await _secureStorage.deleteValue('${address}_sid');
-      logger.d((await _secureStorage.readAll()).toString());
+      await _secureStorage.saveToken(null);
+      await _secureStorage.saveBasicAuthUser(null);
+      await _secureStorage.saveBasicAuthPassword(null);
+      await _secureStorage.savePassword(null);
+      await _secureStorage.saveSid(null);
+      logger.d((await _secureStorage.readEnvironmentData()).toString());
 
       return await _dbInstance.transaction((txn) async {
         await txn.delete('servers', where: 'address = ?', whereArgs: [address]);
@@ -440,7 +415,7 @@
   ///   `false` if it fails.
   Future<bool> deleteServersDataQuery() async {
     try {
-      await _secureStorage.clearAll();
+      await _secureStorage.deleteEnvironmentData();
       return await _dbInstance.transaction((txn) async {
         await txn.delete(
           'servers',
@@ -506,12 +481,10 @@
     try {
       if (column == 'passCode') {
         if (value == null) {
-          await _secureStorage.deleteValue('passCode');
-          return true;
+          return await _secureStorage.savePassCode(null);
         }
 
-        await _secureStorage.saveValue('passCode', value.toString());
-        return true;
+        return await _secureStorage.savePassCode(value.toString());
       }
 
       return await _dbInstance.transaction((txn) async {
@@ -540,7 +513,7 @@
   ///   `false` if it fails.
   Future<bool> restoreAppConfigQuery() async {
     try {
-      await _secureStorage.deleteValue('passCode');
+      await _secureStorage.savePassCode(null);
       return await _dbInstance.transaction((txn) async {
         await txn.update(
           'appConfig',

lib/repository/secure_storage.dart

@@ -1,33 +1,172 @@
 import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 
+/// Secure storage repository
+///
+/// This class is used to store and retrieve sensitive data securely.
+///
+/// Parameters:
+/// - [secureStorage]: FlutterSecureStorage instance: Secure storage instance
+/// - [address]: String: Server address. Default is 'http://localhost:80'
+/// - [environment]: String: Environment name. Default is 'prd'
 class SecureStorageRepository {
   final FlutterSecureStorage _secureStorage;
+  final String _address;
+  final String _environment;
 
-  SecureStorageRepository({FlutterSecureStorage? secureStorage})
-      : _secureStorage = secureStorage ?? const FlutterSecureStorage();
+  Future<String?> get sid async {
+    return await _readValue(_sidKey);
+  }
+
+  Future<String?> get password async {
+    return await _readValue(_passwordKey);
+  }
+
+  Future<String?> get token async {
+    return await _readValue(_tokenKey);
+  }
+
+  Future<String?> get basicAuthUser async {
+    return await _readValue(_basicAuthUserKey);
+  }
+
+  Future<String?> get basicAuthPassword async {
+    return await _readValue(_basicAuthPasswordKey);
+  }
+
+  Future<String?> get passCode async {
+    return await _readValue(_passCodeKey);
+  }
+
+  String get _sidKey => '${_environment}_${_address}_sid';
+  String get _passwordKey => '${_environment}_${_address}_password';
+  String get _tokenKey => '${_environment}_${_address}_token';
+  String get _basicAuthUserKey => '${_environment}_${_address}_basicAuthUser';
+  String get _basicAuthPasswordKey =>
+      '${_environment}_${_address}_basicAuthPassword';
+  String get _passCodeKey => '${_environment}_passCode';
+
+  SecureStorageRepository({
+    FlutterSecureStorage? secureStorage,
+    String? address,
+    String? environment,
+  })  : _secureStorage = secureStorage ?? const FlutterSecureStorage(),
+        _address = address ?? 'http://localhost',
+        _environment = environment ?? 'prd';
+
+  Future<bool> saveSid(String? sid) async {
+    return await _writeValue(_sidKey, sid);
+  }
 
-  // Save a value securely
-  Future<void> saveValue(String key, String value) async {
-    await _secureStorage.write(key: key, value: value);
+  Future<bool> savePassword(String? password) async {
+    return await _writeValue(_passwordKey, password);
   }
 
-  // Retrieve a value securely
-  Future<String?> getValue(String key) async {
-    return await _secureStorage.read(key: key);
+  Future<bool> saveToken(String? token) async {
+    return await _writeValue(_tokenKey, token);
   }
 
-  // Delete a value
-  Future<void> deleteValue(String key) async {
-    await _secureStorage.delete(key: key);
+  Future<bool> saveBasicAuthUser(String? basicAuthUser) async {
+    return await _writeValue(_basicAuthUserKey, basicAuthUser);
   }
 
-  // Clear all values
-  Future<void> clearAll() async {
-    await _secureStorage.deleteAll();
+  Future<bool> saveBasicAuthPassword(String? basicAuthPassword) async {
+    return await _writeValue(_basicAuthPasswordKey, basicAuthPassword);
   }
 
+  Future<bool> savePassCode(String? passCode) async {
+    return await _writeValue(_passCodeKey, passCode);
+  }
+
+  /// Read all environment data
+  ///
+  /// This method reads all values stored in the secure storage for a specific environment.
+  Future<Map<String, String>> readEnvironmentData({String? environment}) async {
+    try {
+      final allData = await _secureStorage.readAll();
+      final environmentData = Map<String, String>.fromEntries(
+        allData.entries
+            .where((entry) => entry.key.startsWith(environment ?? _environment))
+            .map(
+              (entry) => MapEntry(
+                entry.key,
+                entry.value,
+              ),
+            ),
+      );
+      return environmentData;
+    } catch (e) {
+      return {};
+    }
+  }
+
+  /// Delete all environment data
+  ///
+  /// This method deletes all values stored in the secure storage for a specific environment.
+  Future<bool> deleteEnvironmentData({String? environment}) async {
+    try {
+      final allData = await _secureStorage.readAll();
+      final environmentKeys = allData.keys
+          .where((key) => key.startsWith(environment ?? _environment))
+          .toList();
+
+      for (final key in environmentKeys) {
+        await _secureStorage.delete(key: key);
+      }
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Read all values
+  ///
+  /// This method reads all values stored in the secure storage.
   Future<Map<String, String>> readAll() async {
     Map<String, String> allValues = await _secureStorage.readAll();
     return allValues;
   }
+
+  /// Delete all values
+  ///
+  /// This method deletes all values stored in the secure storage.
+  Future<bool> deleteAll() async {
+    try {
+      await _secureStorage.deleteAll();
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Read a value, if the key does not exist, return null
+  Future<String?> _readValue(String key) async {
+    try {
+      return await _secureStorage.read(key: key);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Write a value, if the value is null, delete the key
+  Future<bool> _writeValue(String key, String? value) async {
+    try {
+      if (value == null) {
+        return await _deleteValue(key);
+      }
+      await _secureStorage.write(key: key, value: value);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Delete a value
+  Future<bool> _deleteValue(String key) async {
+    try {
+      await _secureStorage.delete(key: key);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
 }