chore: Move volume functions to provider layer for Hetzner

lib/logic/api_maps/rest_maps/server_providers/hetzner/hetzner_api.dart

@@ -11,7 +11,6 @@ import 'package:selfprivacy/logic/models/hive/server_details.dart';
 import 'package:selfprivacy/logic/models/hive/user.dart';
 import 'package:selfprivacy/logic/models/price.dart';
 import 'package:selfprivacy/logic/models/server_provider_location.dart';
-import 'package:selfprivacy/utils/network_utils.dart';
 import 'package:selfprivacy/utils/password_generator.dart';
 
 class HetznerApi extends ServerProviderApi with VolumeProviderApi {
@@ -129,9 +128,7 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
           );
   }
 
-  Future<GenericResult<ServerVolume?>> createVolume() async {
+  Future<GenericResult> createVolume() async {
-    ServerVolume? volume;
-
     Response? createVolumeResponse;
     final Dio client = await getClient();
     try {
@@ -146,18 +143,6 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
           'format': 'ext4'
         },
       );
-      final volumeId = createVolumeResponse.data['volume']['id'];
-      final volumeSize = createVolumeResponse.data['volume']['size'];
-      final volumeServer = createVolumeResponse.data['volume']['server'];
-      final volumeName = createVolumeResponse.data['volume']['name'];
-      final volumeDevice = createVolumeResponse.data['volume']['linux_device'];
-      volume = ServerVolume(
-        id: volumeId,
-        name: volumeName,
-        sizeByte: volumeSize,
-        serverId: volumeServer,
-        linuxDevice: volumeDevice,
-      );
     } catch (e) {
       print(e);
       return GenericResult(
@@ -170,17 +155,17 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
     }
 
     return GenericResult(
-      data: volume,
+      data: createVolumeResponse.data,
       success: true,
       code: createVolumeResponse.statusCode,
       message: createVolumeResponse.statusMessage,
     );
   }
 
-  Future<List<ServerVolume>> getVolumes({final String? status}) async {
+  Future<GenericResult<List>> getVolumes({final String? status}) async {
-    final List<ServerVolume> volumes = [];
+    List volumes = [];
 
-    final Response getVolumesResonse;
+    Response? getVolumesResonse;
     final Dio client = await getClient();
     try {
       getVolumesResonse = await client.get(
@@ -189,29 +174,24 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
           'status': status,
         },
       );
-      final List<dynamic> rawVolumes = getVolumesResonse.data['volumes'];
+      volumes = getVolumesResonse.data['volumes'];
-      for (final rawVolume in rawVolumes) {
-        final int volumeId = rawVolume['id'];
-        final int volumeSize = rawVolume['size'] * 1024 * 1024 * 1024;
-        final volumeServer = rawVolume['server'];
-        final String volumeName = rawVolume['name'];
-        final volumeDevice = rawVolume['linux_device'];
-        final volume = ServerVolume(
-          id: volumeId,
-          name: volumeName,
-          sizeByte: volumeSize,
-          serverId: volumeServer,
-          linuxDevice: volumeDevice,
-        );
-        volumes.add(volume);
-      }
     } catch (e) {
       print(e);
+      return GenericResult(
+        data: [],
+        success: false,
+        message: e.toString(),
+      );
     } finally {
       client.close();
     }
 
-    return volumes;
+    return GenericResult(
+      data: volumes,
+      success: true,
+      code: getVolumesResonse.statusCode,
+      message: getVolumesResonse.statusMessage,
+    );
   }
 
   Future<ServerVolume?> getVolume(
@@ -244,7 +224,7 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
     return volume;
   }
 
-  Future<GenericResult<void>> deleteVolume(final int volumeId) async {
+  Future<GenericResult<bool>> deleteVolume(final int volumeId) async {
     final Dio client = await getClient();
     try {
       await client.delete('/volumes/$volumeId');
@@ -252,7 +232,7 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
       print(e);
       return GenericResult(
         success: false,
-        data: null,
+        data: false,
         message: e.toString(),
       );
     } finally {
@@ -261,7 +241,7 @@ class HetznerApi extends ServerProviderApi with VolumeProviderApi {
 
     return GenericResult(
       success: true,
-      data: null,
+      data: true,
     );
   }
 

lib/logic/providers/server_providers/hetzner.dart

@@ -631,4 +631,124 @@ class HetznerServerProvider extends ServerProvider {
       data: null,
     );
   }
+
+  Future<GenericResult<ServerVolume?>> createVolume() async {
+    ServerVolume? volume;
+
+    final result = await _adapter.api().createVolume();
+
+    if (!result.success || result.data == null) {
+      return GenericResult(
+        data: null,
+        success: false,
+        message: result.message,
+        code: result.code,
+      );
+    }
+
+    try {
+      final volumeId = result.data['volume']['id'];
+      final volumeSize = result.data['volume']['size'];
+      final volumeServer = result.data['volume']['server'];
+      final volumeName = result.data['volume']['name'];
+      final volumeDevice = result.data['volume']['linux_device'];
+      volume = ServerVolume(
+        id: volumeId,
+        name: volumeName,
+        sizeByte: volumeSize,
+        serverId: volumeServer,
+        linuxDevice: volumeDevice,
+      );
+    } catch (e) {
+      print(e);
+      return GenericResult(
+        data: null,
+        success: false,
+        message: e.toString(),
+      );
+    }
+
+    return GenericResult(
+      data: volume,
+      success: true,
+      code: result.code,
+      message: result.message,
+    );
+  }
+
+  Future<GenericResult<List<ServerVolume>>> getVolumes({
+    final String? status,
+  }) async {
+    final List<ServerVolume> volumes = [];
+
+    final result = await _adapter.api().getVolumes();
+
+    if (!result.success) {
+      return GenericResult(
+        data: [],
+        success: false,
+        message: result.message,
+        code: result.code,
+      );
+    }
+
+    try {
+      for (final rawVolume in result.data) {
+        final int volumeId = rawVolume['id'];
+        final int volumeSize = rawVolume['size'] * 1024 * 1024 * 1024;
+        final volumeServer = rawVolume['server'];
+        final String volumeName = rawVolume['name'];
+        final volumeDevice = rawVolume['linux_device'];
+        final volume = ServerVolume(
+          id: volumeId,
+          name: volumeName,
+          sizeByte: volumeSize,
+          serverId: volumeServer,
+          linuxDevice: volumeDevice,
+        );
+        volumes.add(volume);
+      }
+    } catch (e) {
+      return GenericResult(
+        data: [],
+        success: false,
+        message: e.toString(),
+      );
+    }
+
+    return GenericResult(
+      data: volumes,
+      success: true,
+      code: result.code,
+      message: result.message,
+    );
+  }
+
+  Future<GenericResult<void>> deleteVolume(final int volumeId) async =>
+      _adapter.api().deleteVolume(volumeId);
+
+  Future<GenericResult<bool>> attachVolume(
+    final ServerVolume volume,
+    final int serverId,
+  ) async =>
+      _adapter.api().attachVolume(
+            volume,
+            serverId,
+          );
+
+  Future<GenericResult<bool>> detachVolume(
+    final int volumeId,
+  ) async =>
+      _adapter.api().detachVolume(
+            volumeId,
+          );
+
+  Future<bool> resizeVolume(
+    final ServerVolume volume,
+    final DiskSize size,
+  ) async =>
+      _adapter.api().resizeVolume(
+            volume,
+            size,
+          );
 }