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';
|
2022-11-18 03:07:42 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/api_controller.dart';
|
2022-10-16 00:51:10 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/api_factory_settings.dart';
|
2022-10-13 21:15:42 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/dns_providers/dns_provider_api_settings.dart';
|
2022-10-26 16:07:35 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/server_providers/server_provider.dart';
|
2022-10-13 21:15:42 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/server_providers/server_provider_api_settings.dart';
|
2023-05-16 19:55:26 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/staging_options.dart';
|
2022-05-14 02:54:40 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/backblaze_credential.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/hive/server_details.dart';
|
2022-05-18 11:21:11 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/server_domain.dart';
|
2022-05-14 02:54:40 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/user.dart';
|
2022-05-20 22:56:50 +00:00
|
|
|
import 'package:selfprivacy/logic/models/server_basic_info.dart';
|
2021-01-21 07:35:38 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
import 'package:selfprivacy/logic/cubit/server_installation/server_installation_repository.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';
|
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;
|
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-20 14:36:15 +00:00
|
|
|
void setServerProviderType(final ServerProvider providerType) async {
|
|
|
|
await repository.saveServerProviderType(providerType);
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.initServerProviderApiFactory(
|
2022-10-16 00:51:10 +00:00
|
|
|
ServerProviderApiFactorySettings(
|
|
|
|
provider: providerType,
|
|
|
|
),
|
2022-10-11 20:11:13 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-05-09 06:15:48 +00:00
|
|
|
void setDnsProviderType(final DnsProvider providerType) async {
|
|
|
|
await repository.saveDnsProviderType(providerType);
|
|
|
|
ApiController.initDnsProviderApiFactory(
|
|
|
|
DnsProviderApiFactorySettings(
|
|
|
|
provider: providerType,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-10-26 16:07:35 +00:00
|
|
|
ProviderApiTokenValidation serverProviderApiTokenValidation() =>
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.currentServerProviderApiFactory!
|
2022-10-16 00:51:10 +00:00
|
|
|
.getServerProvider()
|
2022-07-14 13:34:08 +00:00
|
|
|
.getApiTokenValidation();
|
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
RegExp getDnsProviderApiTokenValidation() =>
|
|
|
|
ApiController.currentDnsProviderApiFactory!
|
|
|
|
.getDnsProvider()
|
|
|
|
.getApiTokenValidation();
|
2022-07-12 12:54:16 +00:00
|
|
|
|
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 {
|
|
|
|
final APIGenericResult<bool> apiResponse =
|
|
|
|
await ApiController.currentServerProviderApiFactory!
|
|
|
|
.getServerProvider(
|
|
|
|
settings: const ServerProviderApiSettings(
|
|
|
|
isWithToken: false,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
.isApiTokenValid(providerToken);
|
|
|
|
|
|
|
|
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 {
|
2022-11-28 19:55:37 +00:00
|
|
|
final APIGenericResult<bool> apiResponse =
|
|
|
|
await ApiController.currentDnsProviderApiFactory!
|
|
|
|
.getDnsProvider(
|
|
|
|
settings: const DnsProviderApiSettings(isWithToken: false),
|
|
|
|
)
|
|
|
|
.isApiTokenValid(providerToken);
|
|
|
|
|
|
|
|
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 {
|
2022-11-18 03:07:42 +00:00
|
|
|
if (ApiController.currentServerProviderApiFactory == null) {
|
2022-10-15 19:49:31 +00:00
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2022-11-28 19:11:08 +00:00
|
|
|
final APIGenericResult apiResult = await ApiController
|
|
|
|
.currentServerProviderApiFactory!
|
2022-10-16 00:51:10 +00:00
|
|
|
.getServerProvider()
|
2022-10-15 21:51:37 +00:00
|
|
|
.getAvailableLocations();
|
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 21:51:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Future<List<ServerType>> fetchAvailableTypesByLocation(
|
|
|
|
final ServerProviderLocation location,
|
|
|
|
) async {
|
2022-11-18 03:07:42 +00:00
|
|
|
if (ApiController.currentServerProviderApiFactory == null) {
|
2022-10-15 21:51:37 +00:00
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2022-11-28 19:11:08 +00:00
|
|
|
final APIGenericResult apiResult = await ApiController
|
|
|
|
.currentServerProviderApiFactory!
|
2022-10-16 00:51:10 +00:00
|
|
|
.getServerProvider()
|
2022-10-15 21:51:37 +00:00
|
|
|
.getServerTypesByLocation(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
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2022-10-16 00:51:10 +00:00
|
|
|
void setServerType(final ServerType serverType) async {
|
|
|
|
await repository.saveServerType(serverType);
|
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.initServerProviderApiFactory(
|
|
|
|
ServerProviderApiFactorySettings(
|
|
|
|
provider: getIt<ApiConfigModel>().serverProvider!,
|
|
|
|
location: serverType.location.identifier,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
|
|
|
|
// All server providers support volumes for now,
|
|
|
|
// so it's safe to initialize.
|
|
|
|
ApiController.initVolumeProviderApiFactory(
|
2022-10-16 00:51:10 +00:00
|
|
|
ServerProviderApiFactorySettings(
|
2022-10-20 14:36:15 +00:00
|
|
|
provider: getIt<ApiConfigModel>().serverProvider!,
|
2022-10-16 00:51:10 +00:00
|
|
|
location: serverType.location.identifier,
|
|
|
|
),
|
|
|
|
);
|
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-12 19:32:19 +00:00
|
|
|
setAndValidateDnsApiToken(dnsApiToken);
|
2022-05-24 17:45:13 +00:00
|
|
|
return;
|
|
|
|
}
|
2023-05-12 19:32:19 +00:00
|
|
|
await repository.saveDnsProviderKey(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 {
|
|
|
|
final BackblazeCredential backblazeCredential = BackblazeCredential(
|
2022-05-14 02:54:40 +00:00
|
|
|
keyId: keyId,
|
|
|
|
applicationKey: applicationKey,
|
|
|
|
);
|
|
|
|
await repository.saveBackblazeKey(backblazeCredential);
|
2022-05-23 14:21:34 +00:00
|
|
|
if (state is ServerInstallationRecovery) {
|
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
|
|
|
}
|
|
|
|
|
|
|
|
void createServerAndSetDnsRecords() async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerInstallationNotFinished stateCopy =
|
2022-05-17 13:31:34 +00:00
|
|
|
state as ServerInstallationNotFinished;
|
2022-06-05 19:36:32 +00:00
|
|
|
void onCancel() => emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(isLoading: false),
|
|
|
|
);
|
2022-05-16 22:15:16 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> onSuccess(final ServerHostingDetails serverDetails) async {
|
2022-07-13 11:58:23 +00:00
|
|
|
await repository.createDnsRecords(
|
|
|
|
serverDetails,
|
2022-05-14 02:54:40 +00:00
|
|
|
state.serverDomain!,
|
2022-05-16 22:15:16 +00:00
|
|
|
onCancel: onCancel,
|
2022-05-14 02:54:40 +00:00
|
|
|
);
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
(state as ServerInstallationNotFinished).copyWith(
|
|
|
|
isLoading: false,
|
|
|
|
serverDetails: serverDetails,
|
|
|
|
),
|
|
|
|
);
|
2022-05-24 18:55:39 +00:00
|
|
|
runDelayed(startServerIfDnsIsOkay, const Duration(seconds: 30), null);
|
|
|
|
}
|
2022-05-14 02:54:40 +00:00
|
|
|
|
|
|
|
try {
|
2022-05-17 13:31:34 +00:00
|
|
|
emit((state as ServerInstallationNotFinished).copyWith(isLoading: true));
|
2022-05-14 02:54:40 +00:00
|
|
|
await repository.createServer(
|
|
|
|
state.rootUser!,
|
|
|
|
state.serverDomain!.domainName,
|
2023-05-12 19:32:19 +00:00
|
|
|
state.dnsApiToken!,
|
2022-05-14 02:54:40 +00:00
|
|
|
state.backblazeCredential!,
|
|
|
|
onCancel: onCancel,
|
|
|
|
onSuccess: onSuccess,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
2022-05-24 18:55:39 +00:00
|
|
|
emit(stateCopy);
|
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-05-16 19:55:26 +00:00
|
|
|
StagingOptions.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,
|
2022-05-24 18:55:39 +00:00
|
|
|
provider: DnsProvider.unknown,
|
2022-05-18 11:21:11 +00:00
|
|
|
zoneId: '',
|
|
|
|
);
|
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
|
|
|
);
|
2022-11-17 07:14:34 +00:00
|
|
|
final ServerProvider provider = 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();
|
|
|
|
if (provider == ServerProvider.unknown ||
|
|
|
|
dnsProvider == DnsProvider.unknown) {
|
2022-11-17 07:14:34 +00:00
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('recovering.generic_error'.tr());
|
|
|
|
return;
|
|
|
|
}
|
2022-05-20 22:56:50 +00:00
|
|
|
await repository.saveServerDetails(serverDetails);
|
2023-05-16 18:49:03 +00:00
|
|
|
await repository.saveDnsProviderType(dnsProvider);
|
2022-11-20 14:31:31 +00:00
|
|
|
setServerProviderType(provider);
|
2023-05-16 18:49:03 +00:00
|
|
|
setDnsProviderType(dnsProvider);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
serverDetails: serverDetails,
|
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,
|
2022-05-24 18:55:39 +00:00
|
|
|
provider: ServerProvider.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;
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
final String? zoneId =
|
|
|
|
await repository.getDomainId(token, serverDomain.domainName);
|
2022-05-23 14:21:34 +00:00
|
|
|
if (zoneId == null) {
|
|
|
|
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,
|
|
|
|
zoneId: zoneId,
|
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
|
|
|
);
|
2023-05-12 19:32:19 +00:00
|
|
|
await repository.saveDnsProviderKey(token);
|
2022-06-05 19:36:32 +00:00
|
|
|
emit(
|
|
|
|
dataState.copyWith(
|
|
|
|
serverDomain: ServerDomain(
|
|
|
|
domainName: serverDomain.domainName,
|
|
|
|
zoneId: zoneId,
|
|
|
|
provider: DnsProvider.cloudflare,
|
|
|
|
),
|
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(
|
2022-06-09 21:13:06 +00:00
|
|
|
final BackblazeCredential backblazeCredential,
|
|
|
|
) 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);
|
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,
|
|
|
|
);
|
|
|
|
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) {
|
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();
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.clearProviderApiFactories();
|
2023-05-16 19:55:26 +00:00
|
|
|
StagingOptions.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
|
|
|
}
|