selfprivacy.org.app/lib/logic/cubit/provider_volumes/provider_volume_cubit.dart

151 lines
4.6 KiB
Dart
Raw Normal View History

import 'dart:async';
2022-09-18 16:26:55 +00:00
import 'package:easy_localization/easy_localization.dart';
2022-08-24 23:45:02 +00:00
import 'package:selfprivacy/config/get_it_config.dart';
import 'package:selfprivacy/logic/api_maps/graphql_maps/server_api/server_api.dart';
2022-08-24 23:45:02 +00:00
import 'package:selfprivacy/logic/common_enum/common_enum.dart';
import 'package:selfprivacy/logic/cubit/app_config_dependent/authentication_dependend_cubit.dart';
import 'package:selfprivacy/logic/models/disk_size.dart';
import 'package:selfprivacy/logic/models/disk_status.dart';
2024-01-31 05:14:23 +00:00
import 'package:selfprivacy/logic/models/hive/server_details.dart';
import 'package:selfprivacy/logic/models/price.dart';
import 'package:selfprivacy/logic/providers/providers_controller.dart';
2022-08-24 23:45:02 +00:00
part 'provider_volume_state.dart';
class ApiProviderVolumeCubit
extends ServerInstallationDependendCubit<ApiProviderVolumeState> {
ApiProviderVolumeCubit(final ServerInstallationCubit serverInstallationCubit)
2022-08-29 16:37:31 +00:00
: super(serverInstallationCubit, const ApiProviderVolumeState.initial());
2022-09-18 22:11:26 +00:00
final ServerApi serverApi = ServerApi();
2022-08-24 23:45:02 +00:00
@override
Future<void> load() async {
if (serverInstallationCubit.state is ServerInstallationFinished) {
unawaited(_refetch());
2022-08-24 23:45:02 +00:00
}
}
Future<Price?> getPricePerGb() async {
Price? price;
final pricingResult =
await ProvidersController.currentServerProvider!.getAdditionalPricing();
if (pricingResult.data == null || !pricingResult.success) {
getIt<NavigationService>().showSnackBar('server.pricing_error'.tr());
return price;
}
price = pricingResult.data!.perVolumeGb;
return price;
}
2022-08-24 23:45:02 +00:00
Future<void> refresh() async {
2022-09-18 22:11:26 +00:00
emit(const ApiProviderVolumeState([], LoadingStatus.refreshing, false));
unawaited(_refetch());
2022-08-24 23:45:02 +00:00
}
Future<void> _refetch() async {
if (ProvidersController.currentServerProvider == null) {
2022-09-18 22:11:26 +00:00
return emit(const ApiProviderVolumeState([], LoadingStatus.error, false));
2022-08-24 23:45:02 +00:00
}
final volumesResult =
await ProvidersController.currentServerProvider!.getVolumes();
2022-08-24 23:45:02 +00:00
if (!volumesResult.success || volumesResult.data.isEmpty) {
2022-09-18 22:11:26 +00:00
return emit(const ApiProviderVolumeState([], LoadingStatus.error, false));
2022-08-24 23:45:02 +00:00
}
emit(
ApiProviderVolumeState(
volumesResult.data,
LoadingStatus.success,
false,
),
);
2022-08-24 23:45:02 +00:00
}
2022-08-26 02:34:25 +00:00
Future<void> attachVolume(final DiskVolume volume) async {
2022-08-24 23:45:02 +00:00
final ServerHostingDetails server = getIt<ApiConfigModel>().serverDetails!;
await ProvidersController.currentServerProvider!
.attachVolume(volume.providerVolume!, server.id);
unawaited(refresh());
2022-08-24 23:45:02 +00:00
}
2022-08-26 02:34:25 +00:00
Future<void> detachVolume(final DiskVolume volume) async {
await ProvidersController.currentServerProvider!
.detachVolume(volume.providerVolume!);
unawaited(refresh());
2022-08-24 23:45:02 +00:00
}
Future<bool> resizeVolume(
final DiskVolume volume,
final DiskSize newSize,
2022-09-18 22:11:26 +00:00
final Function() callback,
2022-08-24 23:45:02 +00:00
) async {
2022-09-18 22:11:26 +00:00
getIt<NavigationService>().showSnackBar(
'Starting resize',
);
emit(state.copyWith(isResizing: true));
final resizedResult =
await ProvidersController.currentServerProvider!.resizeVolume(
volume.providerVolume!,
newSize,
);
if (!resizedResult.success || !resizedResult.data) {
2022-09-18 16:26:55 +00:00
getIt<NavigationService>().showSnackBar(
'storage.extending_volume_error'.tr(),
2022-09-18 16:26:55 +00:00
);
2022-09-18 22:11:26 +00:00
emit(state.copyWith(isResizing: false));
2022-08-24 23:45:02 +00:00
return false;
}
2022-09-18 22:11:26 +00:00
getIt<NavigationService>().showSnackBar(
'Provider volume resized, waiting 10 seconds',
2022-09-18 22:11:26 +00:00
);
await Future.delayed(const Duration(seconds: 10));
2022-08-24 23:45:02 +00:00
await ServerApi().resizeVolume(volume.name);
2022-09-18 22:11:26 +00:00
getIt<NavigationService>().showSnackBar(
'Server volume resized, waiting 20 seconds',
2022-09-18 22:11:26 +00:00
);
await Future.delayed(const Duration(seconds: 20));
getIt<NavigationService>().showSnackBar(
'Restarting server',
);
await refresh();
emit(state.copyWith(isResizing: false));
await callback();
await serverApi.reboot();
2022-08-24 23:45:02 +00:00
return true;
}
Future<void> createVolume(final DiskSize size) async {
final ServerVolume? volume = (await ProvidersController
.currentServerProvider!
.createVolume(size.gibibyte.toInt()))
.data;
2022-08-26 02:34:25 +00:00
final diskVolume = DiskVolume(providerVolume: volume);
2022-08-26 02:34:25 +00:00
await attachVolume(diskVolume);
2022-08-24 23:45:02 +00:00
await Future.delayed(const Duration(seconds: 10));
2022-08-26 02:34:25 +00:00
await ServerApi().mountVolume(volume!.name);
unawaited(refresh());
2022-08-24 23:45:02 +00:00
}
Future<void> deleteVolume(final DiskVolume volume) async {
await ProvidersController.currentServerProvider!
.deleteVolume(volume.providerVolume!);
unawaited(refresh());
2022-08-24 23:45:02 +00:00
}
@override
void clear() {
emit(const ApiProviderVolumeState.initial());
}
}