2021-01-21 21:01:42 +00:00
|
|
|
import 'dart:async';
|
|
|
|
|
2022-05-24 18:55:39 +00:00
|
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
2022-05-20 22:56:50 +00:00
|
|
|
import 'package:easy_localization/easy_localization.dart';
|
2021-01-06 17:35:57 +00:00
|
|
|
import 'package:equatable/equatable.dart';
|
2022-05-20 22:56:50 +00:00
|
|
|
import 'package:selfprivacy/config/get_it_config.dart';
|
2022-11-17 07:14:34 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/server_api/server_api.dart';
|
2023-09-05 21:36:49 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/backblaze.dart';
|
2023-06-16 02:59:48 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/tls_options.dart';
|
2023-08-06 23:28:02 +00:00
|
|
|
import 'package:selfprivacy/logic/models/disk_size.dart';
|
2023-09-05 21:36:49 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/backblaze_bucket.dart';
|
2023-06-16 01:28:45 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/backups_credential.dart';
|
2023-06-19 20:56:00 +00:00
|
|
|
import 'package:selfprivacy/logic/models/callback_dialogue_branching.dart';
|
2022-05-14 02:54:40 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/server_details.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/hive/user.dart';
|
2023-06-19 20:56:00 +00:00
|
|
|
import 'package:selfprivacy/logic/models/launch_installation_data.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/hive/server_domain.dart';
|
2022-06-05 19:36:32 +00:00
|
|
|
import 'package:selfprivacy/logic/cubit/server_installation/server_installation_repository.dart';
|
2023-08-07 10:51:47 +00:00
|
|
|
import 'package:selfprivacy/logic/models/price.dart';
|
2023-06-19 20:56:00 +00:00
|
|
|
import 'package:selfprivacy/logic/models/server_basic_info.dart';
|
2022-10-15 19:49:31 +00:00
|
|
|
import 'package:selfprivacy/logic/models/server_provider_location.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/server_type.dart';
|
2023-06-19 20:56:00 +00:00
|
|
|
import 'package:selfprivacy/logic/providers/provider_settings.dart';
|
|
|
|
import 'package:selfprivacy/logic/providers/providers_controller.dart';
|
2023-06-15 16:48:23 +00:00
|
|
|
import 'package:selfprivacy/ui/helpers/modals.dart';
|
2022-02-08 06:59:19 +00:00
|
|
|
|
2021-03-18 00:55:38 +00:00
|
|
|
export 'package:provider/provider.dart';
|
2021-01-06 17:35:57 +00:00
|
|
|
|
2022-05-17 13:31:34 +00:00
|
|
|
part '../server_installation/server_installation_state.dart';
|
2021-01-06 17:35:57 +00:00
|
|
|
|
2022-05-17 13:31:34 +00:00
|
|
|
class ServerInstallationCubit extends Cubit<ServerInstallationState> {
|
2022-05-24 18:55:39 +00:00
|
|
|
ServerInstallationCubit() : super(const ServerInstallationEmpty());
|
2021-01-06 17:35:57 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRepository repository =
|
|
|
|
ServerInstallationRepository();
|
2021-01-06 17:35:57 +00:00
|
|
|
|
2022-05-14 02:54:40 +00:00
|
|
|
Timer? timer;
|
|
|
|
|
2023-08-06 23:28:02 +00:00
|
|
|
final DiskSize initialStorage = DiskSize.fromGibibyte(10);
|
|
|
|
|
2021-03-31 14:33:58 +00:00
|
|
|
Future<void> load() async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationState state = await repository.load();
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-17 13:31:34 +00:00
|
|
|
if (state is ServerInstallationFinished) {
|
2021-02-16 18:48:15 +00:00
|
|
|
emit(state);
|
2022-05-17 13:31:34 +00:00
|
|
|
} else if (state is ServerInstallationNotFinished) {
|
2022-05-13 13:57:56 +00:00
|
|
|
if (state.progress == ServerSetupProgress.serverCreated) {
|
|
|
|
startServerIfDnsIsOkay(state: state);
|
|
|
|
} else if (state.progress == ServerSetupProgress.serverStarted) {
|
|
|
|
resetServerIfServerIsOkay(state: state);
|
|
|
|
} else if (state.progress == ServerSetupProgress.serverResetedFirstTime) {
|
|
|
|
oneMoreReset(state: state);
|
|
|
|
} else if (state.progress ==
|
|
|
|
ServerSetupProgress.serverResetedSecondTime) {
|
|
|
|
finishCheckIfServerIsOkay(state: state);
|
2021-10-13 21:49:24 +00:00
|
|
|
} else {
|
|
|
|
emit(state);
|
2021-09-29 13:08:19 +00:00
|
|
|
}
|
2022-05-17 13:31:34 +00:00
|
|
|
} else if (state is ServerInstallationRecovery) {
|
2022-05-13 13:57:56 +00:00
|
|
|
emit(state);
|
2021-09-29 13:08:19 +00:00
|
|
|
} else {
|
|
|
|
throw 'wrong state';
|
2021-02-16 18:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-30 15:44:52 +00:00
|
|
|
void setServerProviderType(final ServerProviderType providerType) async {
|
2022-10-20 14:36:15 +00:00
|
|
|
await repository.saveServerProviderType(providerType);
|
2023-01-30 15:44:52 +00:00
|
|
|
ProvidersController.initServerProvider(
|
|
|
|
ServerProviderSettings(provider: providerType),
|
2022-10-11 20:11:13 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-01-30 15:44:52 +00:00
|
|
|
void setDnsProviderType(final DnsProviderType providerType) async {
|
2023-05-09 06:15:48 +00:00
|
|
|
await repository.saveDnsProviderType(providerType);
|
2023-05-03 03:01:44 +00:00
|
|
|
ProvidersController.initDnsProvider(
|
2023-05-03 02:42:18 +00:00
|
|
|
DnsProviderSettings(
|
2023-05-09 06:15:48 +00:00
|
|
|
provider: providerType,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<bool?> isServerProviderApiTokenValid(
|
2022-07-14 13:34:08 +00:00
|
|
|
final String providerToken,
|
2022-11-28 18:51:37 +00:00
|
|
|
) async {
|
2023-02-13 14:13:32 +00:00
|
|
|
final GenericResult<bool> apiResponse =
|
|
|
|
await ProvidersController.currentServerProvider!.tryInitApiByToken(
|
2023-01-30 15:44:52 +00:00
|
|
|
providerToken,
|
|
|
|
);
|
2022-11-28 18:51:37 +00:00
|
|
|
|
|
|
|
if (!apiResponse.success) {
|
|
|
|
getIt<NavigationService>().showSnackBar(
|
|
|
|
'initializing.could_not_connect'.tr(),
|
|
|
|
);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return apiResponse.data;
|
|
|
|
}
|
2022-07-14 13:34:08 +00:00
|
|
|
|
2022-11-28 19:55:37 +00:00
|
|
|
Future<bool?> isDnsProviderApiTokenValid(
|
2022-07-14 13:34:08 +00:00
|
|
|
final String providerToken,
|
2022-11-18 03:07:42 +00:00
|
|
|
) async {
|
2023-02-13 14:13:32 +00:00
|
|
|
final GenericResult<bool> apiResponse =
|
2023-05-03 03:01:44 +00:00
|
|
|
await ProvidersController.currentDnsProvider!.tryInitApiByToken(
|
|
|
|
providerToken,
|
|
|
|
);
|
2022-11-28 19:55:37 +00:00
|
|
|
|
|
|
|
if (!apiResponse.success) {
|
|
|
|
getIt<NavigationService>().showSnackBar(
|
|
|
|
'initializing.could_not_connect'.tr(),
|
|
|
|
);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return apiResponse.data;
|
2022-11-18 03:07:42 +00:00
|
|
|
}
|
2022-07-12 12:54:16 +00:00
|
|
|
|
2022-10-15 19:49:31 +00:00
|
|
|
Future<List<ServerProviderLocation>> fetchAvailableLocations() async {
|
2023-02-07 16:51:15 +00:00
|
|
|
if (ProvidersController.currentServerProvider == null) {
|
2022-10-15 19:49:31 +00:00
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2023-02-13 14:13:32 +00:00
|
|
|
final GenericResult apiResponse = await ProvidersController
|
2023-02-07 16:51:15 +00:00
|
|
|
.currentServerProvider!
|
2022-10-15 21:51:37 +00:00
|
|
|
.getAvailableLocations();
|
2022-11-28 19:11:08 +00:00
|
|
|
|
2023-02-07 16:51:15 +00:00
|
|
|
if (!apiResponse.success) {
|
2022-11-28 19:11:08 +00:00
|
|
|
getIt<NavigationService>().showSnackBar(
|
|
|
|
'initializing.could_not_connect'.tr(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-02-07 16:51:15 +00:00
|
|
|
return apiResponse.data;
|
2022-10-15 21:51:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Future<List<ServerType>> fetchAvailableTypesByLocation(
|
|
|
|
final ServerProviderLocation location,
|
|
|
|
) async {
|
2023-02-28 03:00:52 +00:00
|
|
|
if (ProvidersController.currentServerProvider == null) {
|
2022-10-15 21:51:37 +00:00
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2023-02-13 14:13:32 +00:00
|
|
|
final GenericResult apiResult = await ProvidersController
|
2023-02-07 16:51:15 +00:00
|
|
|
.currentServerProvider!
|
|
|
|
.getServerTypes(location: location);
|
2022-11-28 19:11:08 +00:00
|
|
|
|
|
|
|
if (!apiResult.success) {
|
|
|
|
getIt<NavigationService>().showSnackBar(
|
|
|
|
'initializing.could_not_connect'.tr(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return apiResult.data;
|
2022-10-15 19:49:31 +00:00
|
|
|
}
|
|
|
|
|
2023-08-07 10:51:47 +00:00
|
|
|
Future<AdditionalPricing?> fetchAvailableAdditionalPricing() async {
|
|
|
|
AdditionalPricing? prices;
|
|
|
|
final pricingResult =
|
|
|
|
await ProvidersController.currentServerProvider!.getAdditionalPricing();
|
|
|
|
if (pricingResult.data == null || !pricingResult.success) {
|
|
|
|
getIt<NavigationService>().showSnackBar('server.pricing_error'.tr());
|
|
|
|
return prices;
|
|
|
|
}
|
|
|
|
|
|
|
|
prices = pricingResult.data;
|
|
|
|
return prices;
|
|
|
|
}
|
|
|
|
|
2022-10-11 20:11:13 +00:00
|
|
|
void setServerProviderKey(final String serverProviderKey) async {
|
|
|
|
await repository.saveServerProviderKey(serverProviderKey);
|
2022-10-21 04:34:36 +00:00
|
|
|
|
2022-05-19 17:43:25 +00:00
|
|
|
if (state is ServerInstallationRecovery) {
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationRecovery).copyWith(
|
2022-10-11 20:11:13 +00:00
|
|
|
providerApiToken: serverProviderKey,
|
2022-06-05 19:36:32 +00:00
|
|
|
currentStep: RecoveryStep.serverSelection,
|
|
|
|
),
|
|
|
|
);
|
2022-05-20 22:56:50 +00:00
|
|
|
return;
|
2022-05-19 17:43:25 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
2022-07-12 12:54:16 +00:00
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
2022-10-11 20:11:13 +00:00
|
|
|
providerApiToken: serverProviderKey,
|
2022-07-12 12:54:16 +00:00
|
|
|
),
|
2022-06-05 19:36:32 +00:00
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2023-08-07 10:51:47 +00:00
|
|
|
Future<void> setLocationIdentifier(final String locationId) async {
|
|
|
|
await ProvidersController.currentServerProvider!
|
|
|
|
.trySetServerLocation(locationId);
|
|
|
|
}
|
|
|
|
|
2022-10-16 00:51:10 +00:00
|
|
|
void setServerType(final ServerType serverType) async {
|
|
|
|
await repository.saveServerType(serverType);
|
|
|
|
|
2022-10-15 21:51:37 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
2022-10-16 00:51:10 +00:00
|
|
|
serverTypeIdentificator: serverType.identifier,
|
2022-10-15 21:51:37 +00:00
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-05-12 19:32:19 +00:00
|
|
|
void setDnsApiToken(final String dnsApiToken) async {
|
2022-05-24 17:45:13 +00:00
|
|
|
if (state is ServerInstallationRecovery) {
|
2023-05-17 16:58:15 +00:00
|
|
|
await setAndValidateDnsApiToken(dnsApiToken);
|
2022-05-24 17:45:13 +00:00
|
|
|
return;
|
|
|
|
}
|
2022-12-17 10:26:19 +00:00
|
|
|
await repository.setDnsApiToken(dnsApiToken);
|
2022-11-18 03:07:42 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished)
|
2023-05-12 19:32:19 +00:00
|
|
|
.copyWith(dnsApiToken: dnsApiToken),
|
2022-06-05 19:36:32 +00:00
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void setBackblazeKey(final String keyId, final String applicationKey) async {
|
2023-06-16 01:28:45 +00:00
|
|
|
final BackupsCredential backblazeCredential = BackupsCredential(
|
2022-05-14 02:54:40 +00:00
|
|
|
keyId: keyId,
|
|
|
|
applicationKey: applicationKey,
|
2023-06-29 09:52:09 +00:00
|
|
|
provider: BackupsProviderType.backblaze,
|
2022-05-14 02:54:40 +00:00
|
|
|
);
|
2023-09-05 21:36:49 +00:00
|
|
|
final BackblazeBucket? bucket;
|
2022-05-14 02:54:40 +00:00
|
|
|
await repository.saveBackblazeKey(backblazeCredential);
|
2022-05-23 14:21:34 +00:00
|
|
|
if (state is ServerInstallationRecovery) {
|
2023-09-05 21:36:49 +00:00
|
|
|
final configuration = await ServerApi(
|
|
|
|
customToken:
|
|
|
|
(state as ServerInstallationRecovery).serverDetails!.apiToken,
|
|
|
|
isWithToken: true,
|
|
|
|
).getBackupsConfiguration();
|
|
|
|
if (configuration != null) {
|
|
|
|
try {
|
|
|
|
bucket = await BackblazeApi()
|
|
|
|
.fetchBucket(backblazeCredential, configuration);
|
|
|
|
await getIt<ApiConfigModel>().storeBackblazeBucket(bucket!);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
}
|
2022-05-30 13:55:52 +00:00
|
|
|
finishRecoveryProcess(backblazeCredential);
|
2022-05-23 14:21:34 +00:00
|
|
|
return;
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished)
|
|
|
|
.copyWith(backblazeCredential: backblazeCredential),
|
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void setDomain(final ServerDomain serverDomain) async {
|
2022-05-14 02:54:40 +00:00
|
|
|
await repository.saveDomain(serverDomain);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished)
|
|
|
|
.copyWith(serverDomain: serverDomain),
|
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void setRootUser(final User rootUser) async {
|
2022-05-14 02:54:40 +00:00
|
|
|
await repository.saveRootUser(rootUser);
|
2022-05-17 13:31:34 +00:00
|
|
|
emit((state as ServerInstallationNotFinished).copyWith(rootUser: rootUser));
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
|
|
|
|
2023-02-22 17:03:58 +00:00
|
|
|
Future<void> onCreateServerSuccess(
|
|
|
|
final ServerHostingDetails serverDetails,
|
|
|
|
) async {
|
|
|
|
await repository.saveServerDetails(serverDetails);
|
2023-06-19 17:42:48 +00:00
|
|
|
await ProvidersController.currentDnsProvider!.removeDomainRecords(
|
|
|
|
ip4: serverDetails.ip4,
|
|
|
|
domain: state.serverDomain!,
|
|
|
|
);
|
|
|
|
await ProvidersController.currentDnsProvider!.createDomainRecords(
|
|
|
|
ip4: serverDetails.ip4,
|
|
|
|
domain: state.serverDomain!,
|
|
|
|
);
|
|
|
|
|
2023-02-22 17:03:58 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
|
|
|
isLoading: false,
|
|
|
|
serverDetails: serverDetails,
|
2023-06-16 03:52:04 +00:00
|
|
|
installationDialoguePopUp: null,
|
2023-02-22 17:03:58 +00:00
|
|
|
),
|
|
|
|
);
|
|
|
|
runDelayed(startServerIfDnsIsOkay, const Duration(seconds: 30), null);
|
|
|
|
}
|
2022-05-14 02:54:40 +00:00
|
|
|
|
|
|
|
void createServerAndSetDnsRecords() async {
|
2023-02-22 17:03:58 +00:00
|
|
|
emit((state as ServerInstallationNotFinished).copyWith(isLoading: true));
|
2023-02-22 17:58:59 +00:00
|
|
|
|
|
|
|
final installationData = LaunchInstallationData(
|
|
|
|
rootUser: state.rootUser!,
|
|
|
|
dnsApiToken: state.dnsApiToken!,
|
|
|
|
dnsProviderType: state.serverDomain!.provider,
|
2023-04-28 17:19:52 +00:00
|
|
|
serverDomain: state.serverDomain!,
|
2023-02-22 17:58:59 +00:00
|
|
|
serverTypeId: state.serverTypeIdentificator!,
|
|
|
|
errorCallback: clearAppConfig,
|
|
|
|
successCallback: onCreateServerSuccess,
|
2023-08-06 23:28:02 +00:00
|
|
|
storageSize: initialStorage,
|
2023-02-22 17:58:59 +00:00
|
|
|
);
|
2022-05-16 22:15:16 +00:00
|
|
|
|
2023-02-22 17:58:59 +00:00
|
|
|
final result =
|
|
|
|
await ProvidersController.currentServerProvider!.launchInstallation(
|
|
|
|
installationData,
|
2023-02-22 17:03:58 +00:00
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
|
2023-02-22 17:58:59 +00:00
|
|
|
if (!result.success && result.data != null) {
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
2023-06-02 22:04:23 +00:00
|
|
|
installationDialoguePopUp: result.data,
|
2022-06-05 19:36:32 +00:00
|
|
|
),
|
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
}
|
2022-05-13 13:57:56 +00:00
|
|
|
}
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-06-09 21:13:06 +00:00
|
|
|
void startServerIfDnsIsOkay({
|
|
|
|
final ServerInstallationNotFinished? state,
|
|
|
|
}) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished dataState =
|
|
|
|
state ?? this.state as ServerInstallationNotFinished;
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
emit(TimerState(dataState: dataState, isLoading: true));
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final String ip4 = dataState.serverDetails!.ip4;
|
|
|
|
final String domainName = dataState.serverDomain!.domainName;
|
2021-03-25 08:32:00 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final Map<String, bool> matches = await repository.isDnsAddressesMatch(
|
|
|
|
domainName,
|
|
|
|
ip4,
|
2022-06-09 16:15:53 +00:00
|
|
|
dataState.dnsMatches ?? {},
|
2022-06-05 19:36:32 +00:00
|
|
|
);
|
2022-05-13 13:57:56 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
if (matches.values.every((final bool value) => value)) {
|
2022-07-22 16:22:10 +00:00
|
|
|
final ServerHostingDetails server = await repository.startServer(
|
2022-05-13 13:57:56 +00:00
|
|
|
dataState.serverDetails!,
|
|
|
|
);
|
2022-07-12 12:54:16 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
await repository.saveServerDetails(server);
|
|
|
|
await repository.saveIsServerStarted(true);
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished newState = dataState.copyWith(
|
|
|
|
isServerStarted: true,
|
|
|
|
isLoading: false,
|
|
|
|
serverDetails: server,
|
2022-05-13 13:57:56 +00:00
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(newState);
|
2022-05-24 18:55:39 +00:00
|
|
|
runDelayed(
|
2022-06-05 19:36:32 +00:00
|
|
|
resetServerIfServerIsOkay,
|
|
|
|
const Duration(seconds: 60),
|
|
|
|
newState,
|
|
|
|
);
|
2021-02-16 18:48:15 +00:00
|
|
|
} else {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished newState = dataState.copyWith(
|
|
|
|
isLoading: false,
|
|
|
|
dnsMatches: matches,
|
2022-05-13 13:57:56 +00:00
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(newState);
|
2022-05-24 18:55:39 +00:00
|
|
|
runDelayed(
|
2022-06-05 19:36:32 +00:00
|
|
|
startServerIfDnsIsOkay,
|
|
|
|
const Duration(seconds: 30),
|
|
|
|
newState,
|
|
|
|
);
|
2021-02-16 18:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void resetServerIfServerIsOkay({
|
|
|
|
final ServerInstallationNotFinished? state,
|
|
|
|
}) async {
|
|
|
|
final ServerInstallationNotFinished dataState =
|
|
|
|
state ?? this.state as ServerInstallationNotFinished;
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
emit(TimerState(dataState: dataState, isLoading: true));
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final bool isServerWorking = await repository.isHttpServerWorking();
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
if (isServerWorking) {
|
2022-06-05 19:36:32 +00:00
|
|
|
const Duration pauseDuration = Duration(seconds: 30);
|
|
|
|
emit(
|
|
|
|
TimerState(
|
|
|
|
dataState: dataState,
|
|
|
|
timerStart: DateTime.now(),
|
|
|
|
isLoading: false,
|
|
|
|
duration: pauseDuration,
|
|
|
|
),
|
|
|
|
);
|
2022-05-13 13:57:56 +00:00
|
|
|
timer = Timer(pauseDuration, () async {
|
2022-11-12 17:29:06 +00:00
|
|
|
final ServerHostingDetails serverDetails = await repository.restart();
|
2022-06-05 19:36:32 +00:00
|
|
|
await repository.saveIsServerResetedFirstTime(true);
|
2022-11-12 17:29:06 +00:00
|
|
|
await repository.saveServerDetails(serverDetails);
|
2022-05-13 13:57:56 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished newState = dataState.copyWith(
|
|
|
|
isServerResetedFirstTime: true,
|
2022-11-12 17:29:06 +00:00
|
|
|
serverDetails: serverDetails,
|
2022-06-05 19:36:32 +00:00
|
|
|
isLoading: false,
|
2022-05-13 13:57:56 +00:00
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
|
|
|
|
emit(newState);
|
|
|
|
runDelayed(oneMoreReset, const Duration(seconds: 60), newState);
|
2022-05-13 13:57:56 +00:00
|
|
|
});
|
2021-03-31 11:37:39 +00:00
|
|
|
} else {
|
2022-06-05 19:36:32 +00:00
|
|
|
runDelayed(
|
|
|
|
resetServerIfServerIsOkay,
|
|
|
|
const Duration(seconds: 60),
|
|
|
|
dataState,
|
|
|
|
);
|
2021-03-31 11:37:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void oneMoreReset({final ServerInstallationNotFinished? state}) async {
|
|
|
|
final ServerInstallationNotFinished dataState =
|
|
|
|
state ?? this.state as ServerInstallationNotFinished;
|
2021-03-31 11:37:39 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
emit(TimerState(dataState: dataState, isLoading: true));
|
2021-03-31 11:37:39 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final bool isServerWorking = await repository.isHttpServerWorking();
|
2021-03-31 11:37:39 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
if (isServerWorking) {
|
2022-06-05 19:36:32 +00:00
|
|
|
const Duration pauseDuration = Duration(seconds: 30);
|
|
|
|
emit(
|
|
|
|
TimerState(
|
|
|
|
dataState: dataState,
|
|
|
|
timerStart: DateTime.now(),
|
|
|
|
isLoading: false,
|
|
|
|
duration: pauseDuration,
|
|
|
|
),
|
|
|
|
);
|
2022-05-13 13:57:56 +00:00
|
|
|
timer = Timer(pauseDuration, () async {
|
2022-11-12 17:29:06 +00:00
|
|
|
final ServerHostingDetails serverDetails = await repository.restart();
|
2022-06-05 19:36:32 +00:00
|
|
|
await repository.saveIsServerResetedSecondTime(true);
|
2022-11-12 17:29:06 +00:00
|
|
|
await repository.saveServerDetails(serverDetails);
|
2022-05-13 13:57:56 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished newState = dataState.copyWith(
|
|
|
|
isServerResetedSecondTime: true,
|
2022-11-12 17:29:06 +00:00
|
|
|
serverDetails: serverDetails,
|
2022-06-05 19:36:32 +00:00
|
|
|
isLoading: false,
|
|
|
|
);
|
|
|
|
|
|
|
|
emit(newState);
|
|
|
|
runDelayed(
|
|
|
|
finishCheckIfServerIsOkay,
|
|
|
|
const Duration(seconds: 60),
|
|
|
|
newState,
|
2022-05-13 13:57:56 +00:00
|
|
|
);
|
|
|
|
});
|
2021-02-16 18:48:15 +00:00
|
|
|
} else {
|
2022-06-05 19:36:32 +00:00
|
|
|
runDelayed(oneMoreReset, const Duration(seconds: 60), dataState);
|
2021-02-16 18:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void finishCheckIfServerIsOkay({
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished? state,
|
2021-02-16 18:48:15 +00:00
|
|
|
}) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished dataState =
|
|
|
|
state ?? this.state as ServerInstallationNotFinished;
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
emit(TimerState(dataState: dataState, isLoading: true));
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final bool isServerWorking = await repository.isHttpServerWorking();
|
2023-06-16 02:59:48 +00:00
|
|
|
TlsOptions.verifyCertificate = true;
|
2021-02-16 18:48:15 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
if (isServerWorking) {
|
2022-07-22 16:22:10 +00:00
|
|
|
bool dkimCreated = true;
|
|
|
|
try {
|
|
|
|
await repository.createDkimRecord(dataState.serverDomain!);
|
|
|
|
} catch (e) {
|
|
|
|
dkimCreated = false;
|
|
|
|
}
|
|
|
|
if (dkimCreated) {
|
|
|
|
await repository.saveHasFinalChecked(true);
|
|
|
|
emit(dataState.finish());
|
|
|
|
} else {
|
|
|
|
runDelayed(
|
|
|
|
finishCheckIfServerIsOkay,
|
|
|
|
const Duration(seconds: 60),
|
|
|
|
dataState,
|
|
|
|
);
|
|
|
|
}
|
2021-02-16 18:48:15 +00:00
|
|
|
} else {
|
2022-05-24 18:55:39 +00:00
|
|
|
runDelayed(
|
2022-06-05 19:36:32 +00:00
|
|
|
finishCheckIfServerIsOkay,
|
|
|
|
const Duration(seconds: 60),
|
|
|
|
dataState,
|
|
|
|
);
|
2021-02-16 18:48:15 +00:00
|
|
|
}
|
2021-01-06 17:35:57 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void runDelayed(
|
|
|
|
final void Function() work,
|
|
|
|
final Duration delay,
|
|
|
|
final ServerInstallationNotFinished? state,
|
|
|
|
) async {
|
|
|
|
final ServerInstallationNotFinished dataState =
|
|
|
|
state ?? this.state as ServerInstallationNotFinished;
|
2022-05-14 02:54:40 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
TimerState(
|
|
|
|
dataState: dataState,
|
|
|
|
timerStart: DateTime.now(),
|
|
|
|
duration: delay,
|
|
|
|
isLoading: false,
|
|
|
|
),
|
|
|
|
);
|
2022-05-14 02:54:40 +00:00
|
|
|
timer = Timer(delay, work);
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void submitDomainForAccessRecovery(final String domain) async {
|
|
|
|
final ServerDomain serverDomain = ServerDomain(
|
2022-05-18 11:21:11 +00:00
|
|
|
domainName: domain,
|
2023-01-30 15:44:52 +00:00
|
|
|
provider: DnsProviderType.unknown,
|
2022-05-18 11:21:11 +00:00
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerRecoveryCapabilities recoveryCapabilities =
|
2022-05-18 11:21:11 +00:00
|
|
|
await repository.getRecoveryCapabilities(serverDomain);
|
|
|
|
|
2022-05-20 22:56:50 +00:00
|
|
|
await repository.saveDomain(serverDomain);
|
2022-05-30 23:06:08 +00:00
|
|
|
await repository.saveIsRecoveringServer(true);
|
2022-05-20 22:56:50 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
ServerInstallationRecovery(
|
|
|
|
serverDomain: serverDomain,
|
|
|
|
recoveryCapabilities: recoveryCapabilities,
|
|
|
|
currentStep: RecoveryStep.selecting,
|
|
|
|
),
|
|
|
|
);
|
2022-05-18 11:21:11 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void tryToRecover(
|
2022-06-09 21:13:06 +00:00
|
|
|
final String token,
|
|
|
|
final ServerRecoveryMethods method,
|
|
|
|
) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
|
|
|
final ServerDomain? serverDomain = dataState.serverDomain;
|
2022-05-18 11:21:11 +00:00
|
|
|
if (serverDomain == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
try {
|
2022-05-26 01:02:06 +00:00
|
|
|
Future<ServerHostingDetails> Function(
|
2022-06-05 19:36:32 +00:00
|
|
|
ServerDomain,
|
|
|
|
String,
|
|
|
|
ServerRecoveryCapabilities,
|
|
|
|
) recoveryFunction;
|
2022-05-18 11:21:11 +00:00
|
|
|
switch (method) {
|
|
|
|
case ServerRecoveryMethods.newDeviceKey:
|
|
|
|
recoveryFunction = repository.authorizeByNewDeviceKey;
|
|
|
|
break;
|
|
|
|
case ServerRecoveryMethods.recoveryKey:
|
|
|
|
recoveryFunction = repository.authorizeByRecoveryKey;
|
|
|
|
break;
|
|
|
|
case ServerRecoveryMethods.oldToken:
|
|
|
|
recoveryFunction = repository.authorizeByApiToken;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
throw Exception('Unknown recovery method');
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerHostingDetails serverDetails = await recoveryFunction(
|
2022-05-18 11:21:11 +00:00
|
|
|
serverDomain,
|
|
|
|
token,
|
2022-05-26 01:02:06 +00:00
|
|
|
dataState.recoveryCapabilities,
|
2022-05-18 11:21:11 +00:00
|
|
|
);
|
2023-01-30 15:44:52 +00:00
|
|
|
final ServerProviderType serverProvider = await ServerApi(
|
2022-11-18 01:19:54 +00:00
|
|
|
customToken: serverDetails.apiToken,
|
2022-11-17 07:14:34 +00:00
|
|
|
isWithToken: true,
|
|
|
|
).getServerProviderType();
|
2023-05-16 18:49:03 +00:00
|
|
|
final dnsProvider = await ServerApi(
|
|
|
|
customToken: serverDetails.apiToken,
|
|
|
|
isWithToken: true,
|
|
|
|
).getDnsProviderType();
|
2023-05-17 16:58:15 +00:00
|
|
|
if (serverProvider == ServerProviderType.unknown ||
|
|
|
|
dnsProvider == DnsProviderType.unknown) {
|
2022-11-17 07:14:34 +00:00
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('recovering.generic_error'.tr());
|
|
|
|
return;
|
|
|
|
}
|
2023-07-28 23:42:41 +00:00
|
|
|
final newServerDetails = ServerHostingDetails(
|
|
|
|
provider: serverProvider,
|
|
|
|
apiToken: serverDetails.apiToken,
|
|
|
|
createTime: serverDetails.createTime,
|
|
|
|
id: serverDetails.id,
|
|
|
|
ip4: serverDetails.ip4,
|
|
|
|
volume: serverDetails.volume,
|
|
|
|
startTime: serverDetails.startTime,
|
|
|
|
);
|
|
|
|
final newServerDomain = ServerDomain(
|
|
|
|
domainName: serverDomain.domainName,
|
|
|
|
provider: dnsProvider,
|
|
|
|
);
|
|
|
|
await repository.saveServerDetails(newServerDetails);
|
2023-05-16 18:49:03 +00:00
|
|
|
await repository.saveDnsProviderType(dnsProvider);
|
2023-07-28 23:42:41 +00:00
|
|
|
await repository.saveDomain(newServerDomain);
|
2023-01-17 14:33:25 +00:00
|
|
|
setServerProviderType(serverProvider);
|
2023-05-16 18:49:03 +00:00
|
|
|
setDnsProviderType(dnsProvider);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
2023-07-28 23:42:41 +00:00
|
|
|
serverDetails: newServerDetails,
|
|
|
|
serverDomain: newServerDomain,
|
2022-10-11 20:11:13 +00:00
|
|
|
currentStep: RecoveryStep.serverProviderToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
),
|
|
|
|
);
|
2022-05-18 11:21:11 +00:00
|
|
|
} on ServerAuthorizationException {
|
2022-05-20 22:56:50 +00:00
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('recovering.authorization_failed'.tr());
|
2022-05-18 11:21:11 +00:00
|
|
|
return;
|
|
|
|
} on IpNotFoundException {
|
2022-05-20 22:56:50 +00:00
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('recovering.domain_recover_error'.tr());
|
2022-05-18 11:21:11 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-19 14:26:57 +00:00
|
|
|
void revertRecoveryStep() {
|
2022-06-09 21:13:06 +00:00
|
|
|
if (state is ServerInstallationEmpty) {
|
|
|
|
return;
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
2022-05-19 14:26:57 +00:00
|
|
|
switch (dataState.currentStep) {
|
2022-05-24 18:55:39 +00:00
|
|
|
case RecoveryStep.selecting:
|
2022-05-20 22:56:50 +00:00
|
|
|
repository.deleteDomain();
|
2022-05-24 18:55:39 +00:00
|
|
|
emit(const ServerInstallationEmpty());
|
2022-05-19 14:26:57 +00:00
|
|
|
break;
|
2022-05-24 18:55:39 +00:00
|
|
|
case RecoveryStep.recoveryKey:
|
|
|
|
case RecoveryStep.newDeviceKey:
|
|
|
|
case RecoveryStep.oldToken:
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
currentStep: RecoveryStep.selecting,
|
|
|
|
),
|
|
|
|
);
|
2022-05-19 14:26:57 +00:00
|
|
|
break;
|
2023-05-12 19:32:19 +00:00
|
|
|
case RecoveryStep.dnsProviderToken:
|
2022-06-15 03:23:54 +00:00
|
|
|
repository.deleteServerDetails();
|
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
currentStep: RecoveryStep.serverSelection,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
break;
|
2022-05-19 14:26:57 +00:00
|
|
|
// We won't revert steps after client is authorized
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void selectRecoveryMethod(final ServerRecoveryMethods method) {
|
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
2022-05-19 14:26:57 +00:00
|
|
|
switch (method) {
|
|
|
|
case ServerRecoveryMethods.newDeviceKey:
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
currentStep: RecoveryStep.newDeviceKey,
|
|
|
|
),
|
|
|
|
);
|
2022-05-19 14:26:57 +00:00
|
|
|
break;
|
|
|
|
case ServerRecoveryMethods.recoveryKey:
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
currentStep: RecoveryStep.recoveryKey,
|
|
|
|
),
|
|
|
|
);
|
2022-05-19 14:26:57 +00:00
|
|
|
break;
|
|
|
|
case ServerRecoveryMethods.oldToken:
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
currentStep: RecoveryStep.oldToken,
|
|
|
|
),
|
|
|
|
);
|
2022-05-19 14:26:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-12 17:29:06 +00:00
|
|
|
Future<List<ServerBasicInfoWithValidators>> getAvailableServers() async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
|
|
|
final List<ServerBasicInfo> servers =
|
2022-07-12 12:54:16 +00:00
|
|
|
await repository.getServersOnProviderAccount();
|
2022-12-15 11:42:21 +00:00
|
|
|
List<ServerBasicInfoWithValidators> validatedList = [];
|
|
|
|
try {
|
|
|
|
final Iterable<ServerBasicInfoWithValidators> validated = servers.map(
|
|
|
|
(final ServerBasicInfo server) =>
|
|
|
|
ServerBasicInfoWithValidators.fromServerBasicInfo(
|
|
|
|
serverBasicInfo: server,
|
|
|
|
isIpValid: server.ip == dataState.serverDetails?.ip4,
|
|
|
|
isReverseDnsValid:
|
|
|
|
server.reverseDns == dataState.serverDomain?.domainName ||
|
|
|
|
server.reverseDns ==
|
|
|
|
dataState.serverDomain?.domainName.split('.')[0],
|
|
|
|
),
|
|
|
|
);
|
|
|
|
validatedList = validated.toList();
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('modals.server_validators_error'.tr());
|
|
|
|
}
|
|
|
|
|
|
|
|
return validatedList;
|
2022-05-20 22:56:50 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> setServerId(final ServerBasicInfo server) async {
|
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
|
|
|
final ServerDomain? serverDomain = dataState.serverDomain;
|
2022-05-20 22:56:50 +00:00
|
|
|
if (serverDomain == null) {
|
|
|
|
return;
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerHostingDetails serverDetails = ServerHostingDetails(
|
2022-05-20 22:56:50 +00:00
|
|
|
ip4: server.ip,
|
|
|
|
id: server.id,
|
|
|
|
createTime: server.created,
|
|
|
|
volume: ServerVolume(
|
2022-10-17 17:42:23 +00:00
|
|
|
id: 0,
|
2022-05-24 18:55:39 +00:00
|
|
|
name: 'recovered_volume',
|
2022-06-28 18:06:52 +00:00
|
|
|
sizeByte: 0,
|
2022-06-27 07:07:11 +00:00
|
|
|
serverId: server.id,
|
2022-07-31 23:10:37 +00:00
|
|
|
linuxDevice: '',
|
2022-05-20 22:56:50 +00:00
|
|
|
),
|
|
|
|
apiToken: dataState.serverDetails!.apiToken,
|
2023-01-30 15:44:52 +00:00
|
|
|
provider: ServerProviderType.hetzner,
|
2022-05-20 22:56:50 +00:00
|
|
|
);
|
|
|
|
await repository.saveDomain(serverDomain);
|
|
|
|
await repository.saveServerDetails(serverDetails);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
serverDetails: serverDetails,
|
2023-05-12 19:32:19 +00:00
|
|
|
currentStep: RecoveryStep.dnsProviderToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
),
|
|
|
|
);
|
2022-05-20 22:56:50 +00:00
|
|
|
}
|
|
|
|
|
2023-05-12 19:32:19 +00:00
|
|
|
Future<void> setAndValidateDnsApiToken(final String token) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRecovery dataState =
|
|
|
|
state as ServerInstallationRecovery;
|
|
|
|
final ServerDomain? serverDomain = dataState.serverDomain;
|
2022-05-23 14:21:34 +00:00
|
|
|
if (serverDomain == null) {
|
|
|
|
return;
|
|
|
|
}
|
2023-08-01 02:40:25 +00:00
|
|
|
final isTokenValid =
|
|
|
|
await repository.validateDnsToken(token, serverDomain.domainName);
|
|
|
|
if (!isTokenValid) {
|
2022-05-23 14:21:34 +00:00
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('recovering.domain_not_available_on_token'.tr());
|
|
|
|
return;
|
|
|
|
}
|
2023-05-16 18:49:03 +00:00
|
|
|
final dnsProviderType = await ServerApi(
|
|
|
|
customToken: dataState.serverDetails!.apiToken,
|
|
|
|
isWithToken: true,
|
|
|
|
).getDnsProviderType();
|
2022-06-05 19:36:32 +00:00
|
|
|
await repository.saveDomain(
|
|
|
|
ServerDomain(
|
2022-05-23 14:21:34 +00:00
|
|
|
domainName: serverDomain.domainName,
|
2023-05-16 18:49:03 +00:00
|
|
|
provider: dnsProviderType,
|
2022-05-23 14:21:34 +00:00
|
|
|
),
|
2022-06-05 19:36:32 +00:00
|
|
|
);
|
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
serverDomain: ServerDomain(
|
|
|
|
domainName: serverDomain.domainName,
|
2023-05-17 16:58:15 +00:00
|
|
|
provider: dnsProviderType,
|
2022-06-05 19:36:32 +00:00
|
|
|
),
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken: token,
|
2022-06-05 19:36:32 +00:00
|
|
|
currentStep: RecoveryStep.backblazeToken,
|
|
|
|
),
|
|
|
|
);
|
2022-05-23 14:21:34 +00:00
|
|
|
}
|
2022-05-20 22:56:50 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
void finishRecoveryProcess(
|
2023-06-16 01:28:45 +00:00
|
|
|
final BackupsCredential backblazeCredential,
|
2022-06-09 21:13:06 +00:00
|
|
|
) async {
|
2022-05-30 13:55:52 +00:00
|
|
|
await repository.saveIsServerStarted(true);
|
|
|
|
await repository.saveIsServerResetedFirstTime(true);
|
|
|
|
await repository.saveIsServerResetedSecondTime(true);
|
|
|
|
await repository.saveHasFinalChecked(true);
|
2022-05-30 23:06:08 +00:00
|
|
|
await repository.saveIsRecoveringServer(false);
|
2023-07-21 22:48:00 +00:00
|
|
|
final serverType = await ProvidersController.currentServerProvider!
|
|
|
|
.getServerType(state.serverDetails!.id);
|
|
|
|
await repository.saveServerType(serverType.data!);
|
|
|
|
await ProvidersController.currentServerProvider!
|
|
|
|
.trySetServerLocation(serverType.data!.location.identifier);
|
2022-06-05 19:36:32 +00:00
|
|
|
final User mainUser = await repository.getMainUser();
|
2022-05-31 14:30:35 +00:00
|
|
|
await repository.saveRootUser(mainUser);
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationRecovery updatedState =
|
|
|
|
(state as ServerInstallationRecovery).copyWith(
|
2022-05-30 13:55:52 +00:00
|
|
|
backblazeCredential: backblazeCredential,
|
|
|
|
rootUser: mainUser,
|
2023-07-21 22:48:00 +00:00
|
|
|
serverTypeIdentificator: serverType.data!.identifier,
|
2022-05-30 13:55:52 +00:00
|
|
|
);
|
|
|
|
emit(updatedState.finish());
|
|
|
|
}
|
|
|
|
|
2022-05-20 22:56:50 +00:00
|
|
|
@override
|
2022-06-05 19:36:32 +00:00
|
|
|
void onChange(final Change<ServerInstallationState> change) {
|
2023-06-16 03:00:08 +00:00
|
|
|
if (change.nextState.installationDialoguePopUp != null &&
|
2023-06-15 16:48:23 +00:00
|
|
|
change.currentState.installationDialoguePopUp !=
|
2023-06-16 03:00:08 +00:00
|
|
|
change.nextState.installationDialoguePopUp) {
|
|
|
|
final branching = change.nextState.installationDialoguePopUp;
|
2023-06-15 16:48:23 +00:00
|
|
|
showPopUpAlert(
|
|
|
|
alertTitle: branching!.title,
|
|
|
|
description: branching.description,
|
|
|
|
actionButtonTitle: branching.choices[1].title,
|
|
|
|
actionButtonOnPressed: () async {
|
|
|
|
final branchingResult = await branching.choices[1].callback!();
|
2023-06-16 03:52:04 +00:00
|
|
|
if (!branchingResult.success) {
|
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
|
|
|
installationDialoguePopUp: branchingResult.data,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
2023-06-15 16:48:23 +00:00
|
|
|
},
|
|
|
|
cancelButtonTitle: branching.choices[0].title,
|
|
|
|
cancelButtonOnPressed: () async {
|
|
|
|
final branchingResult = await branching.choices[0].callback!();
|
2023-06-16 03:52:04 +00:00
|
|
|
if (!branchingResult.success) {
|
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
|
|
|
installationDialoguePopUp: branchingResult.data,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
2023-06-15 16:48:23 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
2022-05-20 22:56:50 +00:00
|
|
|
super.onChange(change);
|
|
|
|
}
|
|
|
|
|
2021-02-03 19:51:07 +00:00
|
|
|
void clearAppConfig() {
|
2021-03-30 17:38:40 +00:00
|
|
|
closeTimer();
|
2023-02-28 03:00:52 +00:00
|
|
|
ProvidersController.clearProviders();
|
2023-06-16 02:59:48 +00:00
|
|
|
TlsOptions.verifyCertificate = false;
|
2021-02-03 19:51:07 +00:00
|
|
|
repository.clearAppConfig();
|
2022-05-24 18:55:39 +00:00
|
|
|
emit(const ServerInstallationEmpty());
|
2021-01-06 17:35:57 +00:00
|
|
|
}
|
|
|
|
|
2021-04-22 18:04:24 +00:00
|
|
|
Future<void> serverDelete() async {
|
|
|
|
closeTimer();
|
2021-08-29 13:54:28 +00:00
|
|
|
|
2022-05-13 13:57:56 +00:00
|
|
|
if (state.serverDetails != null) {
|
2022-12-22 18:45:06 +00:00
|
|
|
final bool deletionResult =
|
|
|
|
await repository.deleteServer(state.serverDomain!);
|
|
|
|
if (!deletionResult) {
|
|
|
|
return;
|
|
|
|
}
|
2021-04-22 18:04:24 +00:00
|
|
|
}
|
2022-05-31 14:30:35 +00:00
|
|
|
await repository.deleteServerRelatedRecords();
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
ServerInstallationNotFinished(
|
2022-07-12 12:54:16 +00:00
|
|
|
providerApiToken: state.providerApiToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
serverDomain: state.serverDomain,
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken: state.dnsApiToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
backblazeCredential: state.backblazeCredential,
|
|
|
|
rootUser: state.rootUser,
|
|
|
|
serverDetails: null,
|
|
|
|
isServerStarted: false,
|
|
|
|
isServerResetedFirstTime: false,
|
|
|
|
isServerResetedSecondTime: false,
|
|
|
|
isLoading: false,
|
|
|
|
dnsMatches: null,
|
|
|
|
),
|
|
|
|
);
|
2021-04-22 18:04:24 +00:00
|
|
|
}
|
|
|
|
|
2022-05-24 18:55:39 +00:00
|
|
|
@override
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> close() {
|
2021-03-30 17:38:40 +00:00
|
|
|
closeTimer();
|
2021-02-16 18:48:15 +00:00
|
|
|
return super.close();
|
|
|
|
}
|
|
|
|
|
2021-03-30 17:38:40 +00:00
|
|
|
void closeTimer() {
|
2021-03-15 15:39:44 +00:00
|
|
|
if (timer != null && timer!.isActive) {
|
|
|
|
timer!.cancel();
|
2021-02-16 18:48:15 +00:00
|
|
|
}
|
2021-02-03 19:51:07 +00:00
|
|
|
}
|
2021-01-06 17:35:57 +00:00
|
|
|
}
|