2022-05-18 10:39:11 +00:00
|
|
|
import 'dart:io';
|
|
|
|
|
2022-02-08 06:59:19 +00:00
|
|
|
import 'package:basic_utils/basic_utils.dart';
|
2022-05-18 10:39:11 +00:00
|
|
|
import 'package:device_info_plus/device_info_plus.dart';
|
2021-02-15 18:58:29 +00:00
|
|
|
import 'package:dio/dio.dart';
|
2022-02-08 06:59:19 +00:00
|
|
|
import 'package:easy_localization/easy_localization.dart';
|
2022-05-18 10:39:11 +00:00
|
|
|
import 'package:flutter/foundation.dart';
|
2021-01-21 07:35:38 +00:00
|
|
|
import 'package:hive/hive.dart';
|
2022-05-18 10:39:11 +00:00
|
|
|
import 'package:pub_semver/pub_semver.dart';
|
2022-02-08 06:59:19 +00:00
|
|
|
import 'package:selfprivacy/config/get_it_config.dart';
|
2021-01-21 07:35:38 +00:00
|
|
|
import 'package:selfprivacy/config/hive_config.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-07-14 13:34:08 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/dns_providers/dns_provider.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-11-16 00:24:40 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/server_api/server_api.dart';
|
2022-07-14 13:34:08 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/rest_maps/server_providers/server_provider.dart';
|
2023-05-16 18:49:03 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/staging_options.dart';
|
2022-09-04 11:29:05 +00:00
|
|
|
import 'package:selfprivacy/logic/cubit/server_installation/server_installation_cubit.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 08:27:36 +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-18 10:39:11 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/device_token.dart';
|
2022-10-30 14:21:38 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/dns_records.dart';
|
2022-05-18 08:27:36 +00:00
|
|
|
import 'package:selfprivacy/logic/models/message.dart';
|
2022-05-20 22:56:50 +00:00
|
|
|
import 'package:selfprivacy/logic/models/server_basic_info.dart';
|
2022-10-16 00:51:10 +00:00
|
|
|
import 'package:selfprivacy/logic/models/server_type.dart';
|
2022-11-09 15:49:37 +00:00
|
|
|
import 'package:selfprivacy/ui/helpers/modals.dart';
|
2022-10-30 14:21:38 +00:00
|
|
|
import 'package:selfprivacy/utils/network_utils.dart';
|
2022-02-08 06:59:19 +00:00
|
|
|
|
2022-05-18 10:39:11 +00:00
|
|
|
class IpNotFoundException implements Exception {
|
|
|
|
IpNotFoundException(this.message);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String message;
|
2022-05-18 10:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class ServerAuthorizationException implements Exception {
|
|
|
|
ServerAuthorizationException(this.message);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String message;
|
2022-05-18 10:39:11 +00:00
|
|
|
}
|
|
|
|
|
2022-05-17 20:08:28 +00:00
|
|
|
class ServerInstallationRepository {
|
2022-05-18 08:27:36 +00:00
|
|
|
Box box = Hive.box(BNames.serverInstallationBox);
|
2022-06-07 19:59:15 +00:00
|
|
|
Box<User> usersBox = Hive.box(BNames.usersBox);
|
2021-01-21 07:35:38 +00:00
|
|
|
|
2022-05-17 13:31:34 +00:00
|
|
|
Future<ServerInstallationState> load() async {
|
2022-10-11 20:11:13 +00:00
|
|
|
final String? providerApiToken = getIt<ApiConfigModel>().serverProviderKey;
|
2022-10-16 00:51:10 +00:00
|
|
|
final String? location = getIt<ApiConfigModel>().serverLocation;
|
2023-05-12 19:32:19 +00:00
|
|
|
final String? dnsApiToken = getIt<ApiConfigModel>().dnsProviderKey;
|
2022-10-15 21:51:37 +00:00
|
|
|
final String? serverTypeIdentificator = getIt<ApiConfigModel>().serverType;
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerDomain? serverDomain = getIt<ApiConfigModel>().serverDomain;
|
2022-10-21 04:34:36 +00:00
|
|
|
final ServerProvider? serverProvider =
|
|
|
|
getIt<ApiConfigModel>().serverProvider;
|
2022-09-05 04:34:47 +00:00
|
|
|
final BackblazeCredential? backblazeCredential =
|
|
|
|
getIt<ApiConfigModel>().backblazeCredential;
|
|
|
|
final ServerHostingDetails? serverDetails =
|
|
|
|
getIt<ApiConfigModel>().serverDetails;
|
2023-05-12 19:32:19 +00:00
|
|
|
final DnsProvider? dnsProvider = getIt<ApiConfigModel>().dnsProvider;
|
2022-09-05 04:34:47 +00:00
|
|
|
|
2022-10-21 04:34:36 +00:00
|
|
|
if (serverProvider != null ||
|
|
|
|
(serverDetails != null &&
|
|
|
|
serverDetails.provider != ServerProvider.unknown)) {
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.initServerProviderApiFactory(
|
|
|
|
ServerProviderApiFactorySettings(
|
|
|
|
provider: serverProvider ?? serverDetails!.provider,
|
|
|
|
location: location,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
|
|
|
|
// All current providers support volumes
|
|
|
|
// so it's safe to hardcode for now
|
|
|
|
ApiController.initVolumeProviderApiFactory(
|
2022-10-16 00:51:10 +00:00
|
|
|
ServerProviderApiFactorySettings(
|
2022-10-21 04:34:36 +00:00
|
|
|
provider: serverProvider ?? serverDetails!.provider,
|
2022-10-16 00:51:10 +00:00
|
|
|
location: location,
|
|
|
|
),
|
2022-07-14 13:34:08 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2023-05-16 18:49:03 +00:00
|
|
|
if (ApiController.currentDnsProviderApiFactory == null) {
|
|
|
|
if (dnsProvider != null ||
|
|
|
|
(serverDomain != null &&
|
|
|
|
serverDomain.provider != DnsProvider.unknown)) {
|
|
|
|
ApiController.initDnsProviderApiFactory(
|
|
|
|
DnsProviderApiFactorySettings(
|
|
|
|
provider: dnsProvider ?? serverDomain!.provider,
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
2023-05-12 19:32:19 +00:00
|
|
|
}
|
2022-07-12 12:54:16 +00:00
|
|
|
|
2021-09-29 13:08:19 +00:00
|
|
|
if (box.get(BNames.hasFinalChecked, defaultValue: false)) {
|
2023-05-16 18:49:03 +00:00
|
|
|
StagingOptions.verifyCertificate = true;
|
2022-05-17 13:31:34 +00:00
|
|
|
return ServerInstallationFinished(
|
2022-07-12 12:54:16 +00:00
|
|
|
providerApiToken: providerApiToken!,
|
2022-11-20 14:31:31 +00:00
|
|
|
serverTypeIdentificator: serverTypeIdentificator ?? '',
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken: dnsApiToken!,
|
2022-05-13 13:57:56 +00:00
|
|
|
serverDomain: serverDomain!,
|
|
|
|
backblazeCredential: backblazeCredential!,
|
|
|
|
serverDetails: serverDetails!,
|
2021-09-29 13:08:19 +00:00
|
|
|
rootUser: box.get(BNames.rootUser),
|
|
|
|
isServerStarted: box.get(BNames.isServerStarted, defaultValue: false),
|
2022-09-05 04:34:47 +00:00
|
|
|
isServerResetedFirstTime:
|
|
|
|
box.get(BNames.isServerResetedFirstTime, defaultValue: false),
|
|
|
|
isServerResetedSecondTime:
|
|
|
|
box.get(BNames.isServerResetedSecondTime, defaultValue: false),
|
2021-09-29 13:08:19 +00:00
|
|
|
);
|
2022-05-13 13:57:56 +00:00
|
|
|
}
|
|
|
|
|
2022-09-05 04:34:47 +00:00
|
|
|
if (box.get(BNames.isRecoveringServer, defaultValue: false) &&
|
|
|
|
serverDomain != null) {
|
2022-05-17 13:31:34 +00:00
|
|
|
return ServerInstallationRecovery(
|
2022-07-12 12:54:16 +00:00
|
|
|
providerApiToken: providerApiToken,
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken: dnsApiToken,
|
2022-05-13 13:57:56 +00:00
|
|
|
serverDomain: serverDomain,
|
|
|
|
backblazeCredential: backblazeCredential,
|
|
|
|
serverDetails: serverDetails,
|
2021-09-29 13:08:19 +00:00
|
|
|
rootUser: box.get(BNames.rootUser),
|
2022-05-14 02:54:40 +00:00
|
|
|
currentStep: _getCurrentRecoveryStep(
|
2022-07-12 12:54:16 +00:00
|
|
|
providerApiToken,
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken,
|
2022-06-05 22:40:34 +00:00
|
|
|
serverDomain,
|
|
|
|
serverDetails,
|
|
|
|
),
|
2022-05-18 10:39:11 +00:00
|
|
|
recoveryCapabilities: await getRecoveryCapabilities(serverDomain),
|
2021-09-29 13:08:19 +00:00
|
|
|
);
|
|
|
|
}
|
2021-03-25 23:30:34 +00:00
|
|
|
|
2022-05-17 13:31:34 +00:00
|
|
|
return ServerInstallationNotFinished(
|
2022-07-12 12:54:16 +00:00
|
|
|
providerApiToken: providerApiToken,
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsApiToken: dnsApiToken,
|
2022-05-13 13:57:56 +00:00
|
|
|
serverDomain: serverDomain,
|
|
|
|
backblazeCredential: backblazeCredential,
|
|
|
|
serverDetails: serverDetails,
|
|
|
|
rootUser: box.get(BNames.rootUser),
|
|
|
|
isServerStarted: box.get(BNames.isServerStarted, defaultValue: false),
|
2022-09-05 04:34:47 +00:00
|
|
|
isServerResetedFirstTime:
|
|
|
|
box.get(BNames.isServerResetedFirstTime, defaultValue: false),
|
|
|
|
isServerResetedSecondTime:
|
|
|
|
box.get(BNames.isServerResetedSecondTime, defaultValue: false),
|
2022-05-13 13:57:56 +00:00
|
|
|
isLoading: box.get(BNames.isLoading, defaultValue: false),
|
|
|
|
dnsMatches: null,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-05-14 02:54:40 +00:00
|
|
|
RecoveryStep _getCurrentRecoveryStep(
|
2022-10-11 20:11:13 +00:00
|
|
|
final String? serverProviderToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
final String? cloudflareToken,
|
|
|
|
final ServerDomain serverDomain,
|
|
|
|
final ServerHostingDetails? serverDetails,
|
2022-05-13 13:57:56 +00:00
|
|
|
) {
|
|
|
|
if (serverDetails != null) {
|
2022-10-11 20:11:13 +00:00
|
|
|
if (serverProviderToken != null) {
|
2022-05-24 18:55:39 +00:00
|
|
|
if (serverDetails.provider != ServerProvider.unknown) {
|
|
|
|
if (serverDomain.provider != DnsProvider.unknown) {
|
|
|
|
return RecoveryStep.backblazeToken;
|
2022-05-20 22:56:50 +00:00
|
|
|
}
|
2023-05-12 19:32:19 +00:00
|
|
|
return RecoveryStep.dnsProviderToken;
|
2022-05-13 13:57:56 +00:00
|
|
|
}
|
2022-05-24 18:55:39 +00:00
|
|
|
return RecoveryStep.serverSelection;
|
2022-05-13 13:57:56 +00:00
|
|
|
}
|
2022-10-11 20:11:13 +00:00
|
|
|
return RecoveryStep.serverProviderToken;
|
2022-05-13 13:57:56 +00:00
|
|
|
}
|
2022-05-24 18:55:39 +00:00
|
|
|
return RecoveryStep.selecting;
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|
|
|
|
|
2021-02-03 19:51:07 +00:00
|
|
|
void clearAppConfig() {
|
2021-01-21 07:35:38 +00:00
|
|
|
box.clear();
|
2022-06-07 19:59:15 +00:00
|
|
|
usersBox.clear();
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|
|
|
|
|
2022-07-22 16:22:10 +00:00
|
|
|
Future<ServerHostingDetails> startServer(
|
2022-10-11 20:11:13 +00:00
|
|
|
final ServerHostingDetails server,
|
2021-01-21 07:35:38 +00:00
|
|
|
) async {
|
2022-07-22 16:22:10 +00:00
|
|
|
ServerHostingDetails serverDetails;
|
2022-07-12 12:54:16 +00:00
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
serverDetails = await ApiController.currentServerProviderApiFactory!
|
|
|
|
.getServerProvider()
|
|
|
|
.powerOn();
|
2021-01-21 07:35:38 +00:00
|
|
|
|
|
|
|
return serverDetails;
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<String?> getDomainId(final String token, final String domain) async {
|
2022-11-18 03:07:42 +00:00
|
|
|
final DnsProviderApi dnsProviderApi =
|
|
|
|
ApiController.currentDnsProviderApiFactory!.getDnsProvider(
|
2022-07-14 13:34:08 +00:00
|
|
|
settings: DnsProviderApiSettings(
|
|
|
|
isWithToken: false,
|
|
|
|
customToken: token,
|
|
|
|
),
|
2022-05-20 22:56:50 +00:00
|
|
|
);
|
|
|
|
|
2023-06-01 02:12:45 +00:00
|
|
|
/// TODO: nvm it's because only Cloudflare uses Zone
|
|
|
|
/// for other providers we need to implement a different kind of
|
|
|
|
/// functionality here... but it's on refactoring, let it be here for now.
|
|
|
|
final APIGenericResult<bool> apiResponse =
|
|
|
|
await dnsProviderApi.isApiTokenValid(token);
|
|
|
|
|
|
|
|
String? domainId;
|
|
|
|
if (apiResponse.success && apiResponse.data) {
|
|
|
|
domainId = await dnsProviderApi.getZoneId(domain);
|
|
|
|
}
|
2022-09-09 09:14:37 +00:00
|
|
|
return domainId;
|
2022-05-20 22:56:50 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 22:40:34 +00:00
|
|
|
Future<Map<String, bool>> isDnsAddressesMatch(
|
|
|
|
final String? domainName,
|
|
|
|
final String? ip4,
|
2022-06-09 16:15:53 +00:00
|
|
|
final Map<String, bool> skippedMatches,
|
2022-06-05 22:40:34 +00:00
|
|
|
) async {
|
2022-09-05 04:34:47 +00:00
|
|
|
final List<String> addresses = <String>[
|
|
|
|
'$domainName',
|
|
|
|
'api.$domainName',
|
|
|
|
'cloud.$domainName',
|
|
|
|
'meet.$domainName',
|
|
|
|
'password.$domainName'
|
|
|
|
];
|
2021-01-21 07:35:38 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final Map<String, bool> matches = <String, bool>{};
|
2022-02-08 06:59:19 +00:00
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
for (final String address in addresses) {
|
2022-06-09 16:15:53 +00:00
|
|
|
if (skippedMatches[address] ?? false) {
|
2022-02-08 06:59:19 +00:00
|
|
|
matches[address] = true;
|
|
|
|
continue;
|
|
|
|
}
|
2022-06-05 19:36:32 +00:00
|
|
|
final List<RRecord>? lookupRecordRes = await DnsUtils.lookupRecord(
|
2021-01-21 07:35:38 +00:00
|
|
|
address,
|
|
|
|
RRecordType.A,
|
|
|
|
provider: DnsApiProvider.CLOUDFLARE,
|
|
|
|
);
|
|
|
|
getIt.get<ConsoleModel>().addMessage(
|
|
|
|
Message(
|
2022-09-05 04:34:47 +00:00
|
|
|
text:
|
|
|
|
'DnsLookup: address: $address, $RRecordType, provider: CLOUDFLARE, ip4: $ip4',
|
2021-01-21 07:35:38 +00:00
|
|
|
),
|
|
|
|
);
|
|
|
|
getIt.get<ConsoleModel>().addMessage(
|
|
|
|
Message(
|
2022-09-05 04:34:47 +00:00
|
|
|
text:
|
|
|
|
'DnsLookup: ${lookupRecordRes == null ? 'empty' : (lookupRecordRes[0].data != ip4 ? 'wrong ip4' : 'right ip4')}',
|
2021-01-21 07:35:38 +00:00
|
|
|
),
|
|
|
|
);
|
2022-09-05 04:34:47 +00:00
|
|
|
if (lookupRecordRes == null ||
|
|
|
|
lookupRecordRes.isEmpty ||
|
|
|
|
lookupRecordRes[0].data != ip4) {
|
2022-02-08 06:59:19 +00:00
|
|
|
matches[address] = false;
|
|
|
|
} else {
|
|
|
|
matches[address] = true;
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-08 06:59:19 +00:00
|
|
|
return matches;
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|
|
|
|
|
2021-02-15 18:58:29 +00:00
|
|
|
Future<void> createServer(
|
2022-06-05 19:36:32 +00:00
|
|
|
final User rootUser,
|
|
|
|
final String domainName,
|
2023-05-12 19:32:19 +00:00
|
|
|
final String dnsApiToken,
|
2022-06-05 19:36:32 +00:00
|
|
|
final BackblazeCredential backblazeCredential, {
|
|
|
|
required final void Function() onCancel,
|
2022-09-05 04:34:47 +00:00
|
|
|
required final Future<void> Function(ServerHostingDetails serverDetails)
|
|
|
|
onSuccess,
|
2021-02-15 18:58:29 +00:00
|
|
|
}) async {
|
2022-11-18 03:07:42 +00:00
|
|
|
final ServerProviderApi api =
|
|
|
|
ApiController.currentServerProviderApiFactory!.getServerProvider();
|
2022-12-02 18:40:08 +00:00
|
|
|
|
|
|
|
void showInstallationErrorPopUp() {
|
|
|
|
showPopUpAlert(
|
|
|
|
alertTitle: 'modals.unexpected_error'.tr(),
|
|
|
|
description: 'modals.try_again'.tr(),
|
|
|
|
actionButtonTitle: 'modals.yes'.tr(),
|
|
|
|
actionButtonOnPressed: () async {
|
|
|
|
ServerHostingDetails? serverDetails;
|
|
|
|
try {
|
|
|
|
final APIGenericResult createResult = await api.createServer(
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsProvider: getIt<ApiConfigModel>().dnsProvider!,
|
|
|
|
dnsApiToken: dnsApiToken,
|
2022-12-02 18:40:08 +00:00
|
|
|
rootUser: rootUser,
|
|
|
|
domainName: domainName,
|
|
|
|
serverType: getIt<ApiConfigModel>().serverType!,
|
|
|
|
);
|
|
|
|
serverDetails = createResult.data;
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (serverDetails == null) {
|
|
|
|
print('Server is not initialized!');
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
await saveServerDetails(serverDetails);
|
|
|
|
onSuccess(serverDetails);
|
|
|
|
},
|
|
|
|
cancelButtonOnPressed: onCancel,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-02-15 18:58:29 +00:00
|
|
|
try {
|
2022-12-02 18:40:08 +00:00
|
|
|
final APIGenericResult<ServerHostingDetails?> createServerResult =
|
|
|
|
await api.createServer(
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsProvider: getIt<ApiConfigModel>().dnsProvider!,
|
|
|
|
dnsApiToken: dnsApiToken,
|
2021-02-15 18:58:29 +00:00
|
|
|
rootUser: rootUser,
|
|
|
|
domainName: domainName,
|
2022-10-16 01:15:48 +00:00
|
|
|
serverType: getIt<ApiConfigModel>().serverType!,
|
2021-02-15 18:58:29 +00:00
|
|
|
);
|
2022-06-23 21:34:09 +00:00
|
|
|
|
2022-12-02 18:40:08 +00:00
|
|
|
if (createServerResult.data == null) {
|
|
|
|
const String e = 'Server is not initialized!';
|
|
|
|
print(e);
|
2022-06-09 06:51:29 +00:00
|
|
|
}
|
2022-12-02 18:40:08 +00:00
|
|
|
|
|
|
|
if (createServerResult.message == 'uniqueness_error') {
|
2022-11-09 15:49:37 +00:00
|
|
|
showPopUpAlert(
|
|
|
|
alertTitle: 'modals.already_exists'.tr(),
|
|
|
|
description: 'modals.destroy_server'.tr(),
|
|
|
|
actionButtonTitle: 'modals.yes'.tr(),
|
|
|
|
actionButtonOnPressed: () async {
|
|
|
|
await api.deleteServer(
|
|
|
|
domainName: domainName,
|
|
|
|
);
|
|
|
|
|
|
|
|
ServerHostingDetails? serverDetails;
|
|
|
|
try {
|
2022-12-02 18:40:08 +00:00
|
|
|
final APIGenericResult createResult = await api.createServer(
|
2023-05-12 19:32:19 +00:00
|
|
|
dnsProvider: getIt<ApiConfigModel>().dnsProvider!,
|
|
|
|
dnsApiToken: dnsApiToken,
|
2022-11-09 15:49:37 +00:00
|
|
|
rootUser: rootUser,
|
|
|
|
domainName: domainName,
|
|
|
|
serverType: getIt<ApiConfigModel>().serverType!,
|
|
|
|
);
|
2022-12-02 18:40:08 +00:00
|
|
|
serverDetails = createResult.data;
|
2022-11-09 15:49:37 +00:00
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (serverDetails == null) {
|
|
|
|
print('Server is not initialized!');
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
await saveServerDetails(serverDetails);
|
|
|
|
onSuccess(serverDetails);
|
|
|
|
},
|
|
|
|
cancelButtonOnPressed: onCancel,
|
2021-02-15 18:58:29 +00:00
|
|
|
);
|
2022-12-02 19:06:57 +00:00
|
|
|
return;
|
2021-02-15 18:58:29 +00:00
|
|
|
}
|
2022-12-02 18:40:08 +00:00
|
|
|
|
|
|
|
saveServerDetails(createServerResult.data!);
|
|
|
|
onSuccess(createServerResult.data!);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
showInstallationErrorPopUp();
|
2021-02-15 18:58:29 +00:00
|
|
|
}
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|
|
|
|
|
2022-07-12 12:54:16 +00:00
|
|
|
Future<bool> createDnsRecords(
|
2022-07-13 11:58:23 +00:00
|
|
|
final ServerHostingDetails serverDetails,
|
2022-07-12 12:54:16 +00:00
|
|
|
final ServerDomain domain, {
|
2022-06-05 19:36:32 +00:00
|
|
|
required final void Function() onCancel,
|
2022-05-16 22:15:16 +00:00
|
|
|
}) async {
|
2022-09-05 04:34:47 +00:00
|
|
|
final DnsProviderApi dnsProviderApi =
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.currentDnsProviderApiFactory!.getDnsProvider();
|
2022-09-05 04:34:47 +00:00
|
|
|
final ServerProviderApi serverApi =
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.currentServerProviderApiFactory!.getServerProvider();
|
2022-07-12 12:54:16 +00:00
|
|
|
|
2022-11-29 15:21:36 +00:00
|
|
|
void showDomainErrorPopUp(final String error) {
|
2022-11-09 15:49:37 +00:00
|
|
|
showPopUpAlert(
|
2022-11-29 15:21:36 +00:00
|
|
|
alertTitle: error,
|
2022-11-09 15:49:37 +00:00
|
|
|
description: 'modals.delete_server_volume'.tr(),
|
|
|
|
cancelButtonOnPressed: onCancel,
|
|
|
|
actionButtonTitle: 'basis.delete'.tr(),
|
|
|
|
actionButtonOnPressed: () async {
|
|
|
|
await serverApi.deleteServer(
|
|
|
|
domainName: domain.domainName,
|
|
|
|
);
|
|
|
|
onCancel();
|
|
|
|
},
|
2022-05-16 22:15:16 +00:00
|
|
|
);
|
2022-11-29 15:21:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
final APIGenericResult removingResult =
|
|
|
|
await dnsProviderApi.removeSimilarRecords(
|
|
|
|
ip4: serverDetails.ip4,
|
|
|
|
domain: domain,
|
|
|
|
);
|
|
|
|
|
|
|
|
if (!removingResult.success) {
|
|
|
|
showDomainErrorPopUp('domain.error'.tr());
|
2022-07-12 12:54:16 +00:00
|
|
|
return false;
|
2022-05-16 22:15:16 +00:00
|
|
|
}
|
2021-05-17 12:38:38 +00:00
|
|
|
|
2022-11-29 15:21:36 +00:00
|
|
|
bool createdSuccessfully = false;
|
|
|
|
String errorMessage = 'domain.error'.tr();
|
|
|
|
try {
|
|
|
|
final APIGenericResult createResult =
|
|
|
|
await dnsProviderApi.createMultipleDnsRecords(
|
|
|
|
ip4: serverDetails.ip4,
|
|
|
|
domain: domain,
|
|
|
|
);
|
|
|
|
createdSuccessfully = createResult.success;
|
|
|
|
} on DioError catch (e) {
|
|
|
|
if (e.response!.data['errors'][0]['code'] == 1038) {
|
|
|
|
errorMessage = 'modals.you_cant_use_this_api'.tr();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!createdSuccessfully) {
|
|
|
|
showDomainErrorPopUp(errorMessage);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
final APIGenericResult createReverseResult =
|
|
|
|
await serverApi.createReverseDns(
|
2022-07-13 11:58:23 +00:00
|
|
|
serverDetails: serverDetails,
|
|
|
|
domain: domain,
|
|
|
|
);
|
|
|
|
|
2022-11-29 15:21:36 +00:00
|
|
|
if (!createReverseResult.success) {
|
|
|
|
showDomainErrorPopUp(errorMessage);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-07-12 12:54:16 +00:00
|
|
|
return true;
|
2021-01-21 21:01:42 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> createDkimRecord(final ServerDomain cloudFlareDomain) async {
|
2022-09-05 04:34:47 +00:00
|
|
|
final DnsProviderApi dnsProviderApi =
|
2022-11-18 03:07:42 +00:00
|
|
|
ApiController.currentDnsProviderApiFactory!.getDnsProvider();
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi api = ServerApi();
|
2022-02-01 01:56:05 +00:00
|
|
|
|
2022-10-30 14:21:38 +00:00
|
|
|
late DnsRecord record;
|
2022-07-22 16:22:10 +00:00
|
|
|
try {
|
2022-10-30 14:21:38 +00:00
|
|
|
record = extractDkimRecord(await api.getDnsRecords())!;
|
2022-07-22 16:22:10 +00:00
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
rethrow;
|
|
|
|
}
|
2022-02-01 01:56:05 +00:00
|
|
|
|
2022-10-30 14:21:38 +00:00
|
|
|
await dnsProviderApi.setDnsRecord(record, cloudFlareDomain);
|
2022-02-01 01:56:05 +00:00
|
|
|
}
|
|
|
|
|
2021-03-25 23:30:34 +00:00
|
|
|
Future<bool> isHttpServerWorking() async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi api = ServerApi();
|
2022-07-22 16:22:10 +00:00
|
|
|
return api.isHttpServerWorking();
|
2021-01-21 21:01:42 +00:00
|
|
|
}
|
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
Future<ServerHostingDetails> restart() async =>
|
|
|
|
ApiController.currentServerProviderApiFactory!
|
|
|
|
.getServerProvider()
|
|
|
|
.restart();
|
2021-03-31 14:33:58 +00:00
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
Future<ServerHostingDetails> powerOn() async =>
|
|
|
|
ApiController.currentServerProviderApiFactory!
|
|
|
|
.getServerProvider()
|
|
|
|
.powerOn();
|
2021-03-25 08:32:00 +00:00
|
|
|
|
2022-05-18 10:39:11 +00:00
|
|
|
Future<ServerRecoveryCapabilities> getRecoveryCapabilities(
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerDomain serverDomain,
|
2022-05-18 10:39:11 +00:00
|
|
|
) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi serverApi = ServerApi(
|
2022-05-18 10:39:11 +00:00
|
|
|
isWithToken: false,
|
|
|
|
overrideDomain: serverDomain.domainName,
|
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String? serverApiVersion = await serverApi.getApiVersion();
|
2022-05-18 10:39:11 +00:00
|
|
|
if (serverApiVersion == null) {
|
|
|
|
return ServerRecoveryCapabilities.none;
|
|
|
|
}
|
|
|
|
try {
|
2022-06-05 19:36:32 +00:00
|
|
|
final Version parsedVersion = Version.parse(serverApiVersion);
|
2022-05-23 14:21:34 +00:00
|
|
|
if (!VersionConstraint.parse('>=1.2.0').allows(parsedVersion)) {
|
2022-05-18 10:39:11 +00:00
|
|
|
return ServerRecoveryCapabilities.legacy;
|
|
|
|
}
|
|
|
|
return ServerRecoveryCapabilities.loginTokens;
|
|
|
|
} on FormatException {
|
|
|
|
return ServerRecoveryCapabilities.none;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<String> getServerIpFromDomain(final ServerDomain serverDomain) async {
|
|
|
|
final List<RRecord>? lookup = await DnsUtils.lookupRecord(
|
2022-06-05 22:40:34 +00:00
|
|
|
serverDomain.domainName,
|
|
|
|
RRecordType.A,
|
|
|
|
provider: DnsApiProvider.CLOUDFLARE,
|
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
if (lookup == null || lookup.isEmpty) {
|
|
|
|
throw IpNotFoundException('No IP found for domain $serverDomain');
|
|
|
|
}
|
|
|
|
return lookup[0].data;
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<String> getDeviceName() async {
|
|
|
|
final DeviceInfoPlugin deviceInfo = DeviceInfoPlugin();
|
|
|
|
if (kIsWeb) {
|
2022-06-05 22:40:34 +00:00
|
|
|
return deviceInfo.webBrowserInfo.then(
|
2022-09-05 04:34:47 +00:00
|
|
|
(final WebBrowserInfo value) =>
|
|
|
|
'${value.browserName} ${value.platform}',
|
2022-06-05 22:40:34 +00:00
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
} else {
|
|
|
|
if (Platform.isAndroid) {
|
2022-06-05 22:40:34 +00:00
|
|
|
return deviceInfo.androidInfo.then(
|
2022-09-05 04:34:47 +00:00
|
|
|
(final AndroidDeviceInfo value) =>
|
|
|
|
'${value.model} ${value.version.release}',
|
2022-06-05 22:40:34 +00:00
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
} else if (Platform.isIOS) {
|
2022-06-05 22:40:34 +00:00
|
|
|
return deviceInfo.iosInfo.then(
|
2022-09-05 04:34:47 +00:00
|
|
|
(final IosDeviceInfo value) =>
|
|
|
|
'${value.utsname.machine} ${value.systemName} ${value.systemVersion}',
|
2022-06-05 22:40:34 +00:00
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
} else if (Platform.isLinux) {
|
2022-09-05 04:34:47 +00:00
|
|
|
return deviceInfo.linuxInfo
|
|
|
|
.then((final LinuxDeviceInfo value) => value.prettyName);
|
2022-05-18 10:39:11 +00:00
|
|
|
} else if (Platform.isMacOS) {
|
2022-06-05 22:40:34 +00:00
|
|
|
return deviceInfo.macOsInfo.then(
|
2022-09-05 04:34:47 +00:00
|
|
|
(final MacOsDeviceInfo value) =>
|
|
|
|
'${value.hostName} ${value.computerName}',
|
2022-06-05 22:40:34 +00:00
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
} else if (Platform.isWindows) {
|
2022-09-05 04:34:47 +00:00
|
|
|
return deviceInfo.windowsInfo
|
|
|
|
.then((final WindowsDeviceInfo value) => value.computerName);
|
2022-05-18 10:39:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 'Unidentified';
|
|
|
|
}
|
|
|
|
|
2022-05-18 11:21:11 +00:00
|
|
|
Future<ServerHostingDetails> authorizeByNewDeviceKey(
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerDomain serverDomain,
|
|
|
|
final String newDeviceKey,
|
|
|
|
final ServerRecoveryCapabilities recoveryCapabilities,
|
2022-05-18 10:39:11 +00:00
|
|
|
) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi serverApi = ServerApi(
|
2022-05-18 10:39:11 +00:00
|
|
|
isWithToken: false,
|
|
|
|
overrideDomain: serverDomain.domainName,
|
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String serverIp = await getServerIpFromDomain(serverDomain);
|
2022-11-28 18:51:37 +00:00
|
|
|
final APIGenericResult<String> result = await serverApi.authorizeDevice(
|
2022-06-05 22:40:34 +00:00
|
|
|
DeviceToken(device: await getDeviceName(), token: newDeviceKey),
|
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
|
2022-10-28 08:17:08 +00:00
|
|
|
if (result.success) {
|
2022-05-18 10:39:11 +00:00
|
|
|
return ServerHostingDetails(
|
2022-10-28 08:17:08 +00:00
|
|
|
apiToken: result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
volume: ServerVolume(
|
|
|
|
id: 0,
|
|
|
|
name: '',
|
2022-06-28 18:06:52 +00:00
|
|
|
sizeByte: 0,
|
2022-06-27 07:07:11 +00:00
|
|
|
serverId: 0,
|
2022-07-31 23:10:37 +00:00
|
|
|
linuxDevice: '',
|
2022-05-18 10:39:11 +00:00
|
|
|
),
|
2022-05-24 18:55:39 +00:00
|
|
|
provider: ServerProvider.unknown,
|
2022-05-18 10:39:11 +00:00
|
|
|
id: 0,
|
|
|
|
ip4: serverIp,
|
|
|
|
startTime: null,
|
|
|
|
createTime: null,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
throw ServerAuthorizationException(
|
2022-10-28 08:17:08 +00:00
|
|
|
result.message ?? result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-05-18 11:21:11 +00:00
|
|
|
Future<ServerHostingDetails> authorizeByRecoveryKey(
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerDomain serverDomain,
|
|
|
|
final String recoveryKey,
|
|
|
|
final ServerRecoveryCapabilities recoveryCapabilities,
|
2022-05-18 10:39:11 +00:00
|
|
|
) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi serverApi = ServerApi(
|
2022-05-18 10:39:11 +00:00
|
|
|
isWithToken: false,
|
|
|
|
overrideDomain: serverDomain.domainName,
|
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String serverIp = await getServerIpFromDomain(serverDomain);
|
2022-11-28 18:51:37 +00:00
|
|
|
final APIGenericResult<String> result = await serverApi.useRecoveryToken(
|
2022-06-05 22:40:34 +00:00
|
|
|
DeviceToken(device: await getDeviceName(), token: recoveryKey),
|
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
|
2022-10-28 08:17:08 +00:00
|
|
|
if (result.success) {
|
2022-05-18 10:39:11 +00:00
|
|
|
return ServerHostingDetails(
|
2022-10-28 08:17:08 +00:00
|
|
|
apiToken: result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
volume: ServerVolume(
|
|
|
|
id: 0,
|
|
|
|
name: '',
|
2022-06-28 18:06:52 +00:00
|
|
|
sizeByte: 0,
|
2022-06-27 07:07:11 +00:00
|
|
|
serverId: 0,
|
2022-07-31 23:10:37 +00:00
|
|
|
linuxDevice: '',
|
2022-05-18 10:39:11 +00:00
|
|
|
),
|
2022-05-24 18:55:39 +00:00
|
|
|
provider: ServerProvider.unknown,
|
2022-05-18 10:39:11 +00:00
|
|
|
id: 0,
|
2022-05-30 13:55:52 +00:00
|
|
|
ip4: serverIp,
|
2022-05-18 10:39:11 +00:00
|
|
|
startTime: null,
|
|
|
|
createTime: null,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
throw ServerAuthorizationException(
|
2022-10-28 08:17:08 +00:00
|
|
|
result.message ?? result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<ServerHostingDetails> authorizeByApiToken(
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerDomain serverDomain,
|
|
|
|
final String apiToken,
|
|
|
|
final ServerRecoveryCapabilities recoveryCapabilities,
|
2022-05-18 10:39:11 +00:00
|
|
|
) async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi serverApi = ServerApi(
|
2022-12-13 04:15:32 +00:00
|
|
|
isWithToken: true,
|
2022-05-18 10:39:11 +00:00
|
|
|
overrideDomain: serverDomain.domainName,
|
|
|
|
customToken: apiToken,
|
|
|
|
);
|
2022-06-05 19:36:32 +00:00
|
|
|
final String serverIp = await getServerIpFromDomain(serverDomain);
|
2022-05-26 01:02:06 +00:00
|
|
|
if (recoveryCapabilities == ServerRecoveryCapabilities.legacy) {
|
2022-10-24 11:39:53 +00:00
|
|
|
if (await serverApi.isHttpServerWorking()) {
|
2022-05-26 01:02:06 +00:00
|
|
|
return ServerHostingDetails(
|
|
|
|
apiToken: apiToken,
|
|
|
|
volume: ServerVolume(
|
|
|
|
id: 0,
|
|
|
|
name: '',
|
2022-06-27 07:07:11 +00:00
|
|
|
serverId: 0,
|
2022-06-28 18:06:52 +00:00
|
|
|
sizeByte: 0,
|
2022-07-31 23:10:37 +00:00
|
|
|
linuxDevice: '',
|
2022-05-26 01:02:06 +00:00
|
|
|
),
|
|
|
|
provider: ServerProvider.unknown,
|
|
|
|
id: 0,
|
2022-05-30 13:55:52 +00:00
|
|
|
ip4: serverIp,
|
2022-05-26 01:02:06 +00:00
|
|
|
startTime: null,
|
|
|
|
createTime: null,
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
throw ServerAuthorizationException(
|
2022-06-05 19:36:32 +00:00
|
|
|
"Couldn't connect to server with this token",
|
2022-05-26 01:02:06 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
final APIGenericResult<String> deviceAuthKey =
|
2022-09-05 04:34:47 +00:00
|
|
|
await serverApi.createDeviceToken();
|
2022-11-28 18:51:37 +00:00
|
|
|
final APIGenericResult<String> result = await serverApi.authorizeDevice(
|
2022-06-05 22:40:34 +00:00
|
|
|
DeviceToken(device: await getDeviceName(), token: deviceAuthKey.data),
|
|
|
|
);
|
2022-05-18 10:39:11 +00:00
|
|
|
|
2022-10-28 08:17:08 +00:00
|
|
|
if (result.success) {
|
2022-05-18 10:39:11 +00:00
|
|
|
return ServerHostingDetails(
|
2022-10-28 08:17:08 +00:00
|
|
|
apiToken: result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
volume: ServerVolume(
|
|
|
|
id: 0,
|
|
|
|
name: '',
|
2022-06-28 18:06:52 +00:00
|
|
|
sizeByte: 0,
|
2022-06-27 07:07:11 +00:00
|
|
|
serverId: 0,
|
2022-07-31 23:10:37 +00:00
|
|
|
linuxDevice: '',
|
2022-05-18 10:39:11 +00:00
|
|
|
),
|
2022-05-24 18:55:39 +00:00
|
|
|
provider: ServerProvider.unknown,
|
2022-05-18 10:39:11 +00:00
|
|
|
id: 0,
|
2022-06-07 19:59:15 +00:00
|
|
|
ip4: serverIp,
|
2022-05-18 10:39:11 +00:00
|
|
|
startTime: null,
|
|
|
|
createTime: null,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
throw ServerAuthorizationException(
|
2022-10-28 08:17:08 +00:00
|
|
|
result.message ?? result.data,
|
2022-05-18 10:39:11 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2022-05-23 14:21:34 +00:00
|
|
|
Future<User> getMainUser() async {
|
2022-06-05 19:36:32 +00:00
|
|
|
final ServerApi serverApi = ServerApi();
|
|
|
|
const User fallbackUser = User(
|
2022-05-23 14:21:34 +00:00
|
|
|
isFoundOnServer: false,
|
2022-09-04 11:29:05 +00:00
|
|
|
type: UserType.primary,
|
2022-06-05 19:36:32 +00:00
|
|
|
note: "Couldn't find main user on server, API is outdated",
|
2022-05-23 14:21:34 +00:00
|
|
|
login: 'UNKNOWN',
|
|
|
|
sshKeys: [],
|
|
|
|
);
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
final String? serverApiVersion = await serverApi.getApiVersion();
|
2022-10-24 11:39:53 +00:00
|
|
|
final users = await serverApi.getAllUsers();
|
|
|
|
if (serverApiVersion == null || users.isEmpty) {
|
2022-05-23 14:21:34 +00:00
|
|
|
return fallbackUser;
|
|
|
|
}
|
|
|
|
try {
|
2022-06-05 19:36:32 +00:00
|
|
|
final Version parsedVersion = Version.parse(serverApiVersion);
|
2022-05-23 14:21:34 +00:00
|
|
|
if (!VersionConstraint.parse('>=1.2.5').allows(parsedVersion)) {
|
|
|
|
return fallbackUser;
|
|
|
|
}
|
2022-10-24 11:39:53 +00:00
|
|
|
return users.firstWhere(
|
|
|
|
(final User user) => user.type == UserType.primary,
|
2022-05-23 14:21:34 +00:00
|
|
|
);
|
|
|
|
} on FormatException {
|
|
|
|
return fallbackUser;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-18 03:07:42 +00:00
|
|
|
Future<List<ServerBasicInfo>> getServersOnProviderAccount() async =>
|
|
|
|
ApiController.currentServerProviderApiFactory!
|
|
|
|
.getServerProvider()
|
|
|
|
.getServers();
|
2022-05-20 22:56:50 +00:00
|
|
|
|
2022-06-05 22:40:34 +00:00
|
|
|
Future<void> saveServerDetails(
|
|
|
|
final ServerHostingDetails serverDetails,
|
|
|
|
) async {
|
2021-03-25 20:09:56 +00:00
|
|
|
await getIt<ApiConfigModel>().storeServerDetails(serverDetails);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-06-15 03:23:54 +00:00
|
|
|
Future<void> deleteServerDetails() async {
|
|
|
|
await box.delete(BNames.serverDetails);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
|
|
|
|
2022-10-20 14:36:15 +00:00
|
|
|
Future<void> saveServerProviderType(final ServerProvider type) async {
|
|
|
|
await getIt<ApiConfigModel>().storeServerProviderType(type);
|
|
|
|
}
|
|
|
|
|
2022-10-11 20:11:13 +00:00
|
|
|
Future<void> saveServerProviderKey(final String key) async {
|
|
|
|
await getIt<ApiConfigModel>().storeServerProviderKey(key);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-10-16 00:51:10 +00:00
|
|
|
Future<void> saveServerType(final ServerType serverType) async {
|
|
|
|
await getIt<ApiConfigModel>().storeServerTypeIdentifier(
|
|
|
|
serverType.identifier,
|
|
|
|
);
|
|
|
|
await getIt<ApiConfigModel>().storeServerLocation(
|
|
|
|
serverType.location.identifier,
|
|
|
|
);
|
2022-10-15 21:51:37 +00:00
|
|
|
}
|
|
|
|
|
2022-10-11 20:11:13 +00:00
|
|
|
Future<void> deleteServerProviderKey() async {
|
2022-05-20 22:56:50 +00:00
|
|
|
await box.delete(BNames.hetznerKey);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
|
|
|
|
2023-05-09 06:15:48 +00:00
|
|
|
Future<void> saveDnsProviderType(final DnsProvider type) async {
|
|
|
|
await getIt<ApiConfigModel>().storeDnsProviderType(type);
|
|
|
|
}
|
|
|
|
|
2022-06-05 22:40:34 +00:00
|
|
|
Future<void> saveBackblazeKey(
|
|
|
|
final BackblazeCredential backblazeCredential,
|
|
|
|
) async {
|
2021-03-25 20:09:56 +00:00
|
|
|
await getIt<ApiConfigModel>().storeBackblazeCredential(backblazeCredential);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-06-15 03:23:54 +00:00
|
|
|
Future<void> deleteBackblazeKey() async {
|
|
|
|
await box.delete(BNames.backblazeCredential);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
|
|
|
|
2023-05-12 19:32:19 +00:00
|
|
|
Future<void> saveDnsProviderKey(final String key) async {
|
|
|
|
await getIt<ApiConfigModel>().storeDnsProviderKey(key);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2023-05-12 19:32:19 +00:00
|
|
|
Future<void> deleteDnsProviderKey() async {
|
2022-06-15 03:23:54 +00:00
|
|
|
await box.delete(BNames.cloudFlareKey);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveDomain(final ServerDomain serverDomain) async {
|
2022-05-13 13:57:56 +00:00
|
|
|
await getIt<ApiConfigModel>().storeServerDomain(serverDomain);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-05-20 22:56:50 +00:00
|
|
|
Future<void> deleteDomain() async {
|
|
|
|
await box.delete(BNames.serverDomain);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveIsServerStarted(final bool value) async {
|
2021-03-25 20:09:56 +00:00
|
|
|
await box.put(BNames.isServerStarted, value);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveIsServerResetedFirstTime(final bool value) async {
|
2021-03-31 11:37:39 +00:00
|
|
|
await box.put(BNames.isServerResetedFirstTime, value);
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveIsServerResetedSecondTime(final bool value) async {
|
2021-03-31 11:37:39 +00:00
|
|
|
await box.put(BNames.isServerResetedSecondTime, value);
|
2021-03-25 08:32:00 +00:00
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveRootUser(final User rootUser) async {
|
2021-03-25 08:32:00 +00:00
|
|
|
await box.put(BNames.rootUser, rootUser);
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveIsRecoveringServer(final bool value) async {
|
2022-05-30 23:06:08 +00:00
|
|
|
await box.put(BNames.isRecoveringServer, value);
|
|
|
|
}
|
|
|
|
|
2022-06-05 19:36:32 +00:00
|
|
|
Future<void> saveHasFinalChecked(final bool value) async {
|
2021-03-25 08:32:00 +00:00
|
|
|
await box.put(BNames.hasFinalChecked, value);
|
|
|
|
}
|
2021-04-22 18:04:24 +00:00
|
|
|
|
2022-12-22 18:45:06 +00:00
|
|
|
Future<bool> deleteServer(final ServerDomain serverDomain) async {
|
|
|
|
final APIGenericResult<bool> deletionResult = await ApiController
|
|
|
|
.currentServerProviderApiFactory!
|
2022-11-18 03:07:42 +00:00
|
|
|
.getServerProvider()
|
|
|
|
.deleteServer(
|
|
|
|
domainName: serverDomain.domainName,
|
|
|
|
);
|
2021-10-11 21:10:04 +00:00
|
|
|
|
2022-12-22 18:45:06 +00:00
|
|
|
if (!deletionResult.success) {
|
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('modals.server_validators_error'.tr());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!deletionResult.data) {
|
|
|
|
getIt<NavigationService>()
|
|
|
|
.showSnackBar('modals.server_deletion_error'.tr());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-10-13 21:49:24 +00:00
|
|
|
await box.put(BNames.hasFinalChecked, false);
|
|
|
|
await box.put(BNames.isServerStarted, false);
|
|
|
|
await box.put(BNames.isServerResetedFirstTime, false);
|
|
|
|
await box.put(BNames.isServerResetedSecondTime, false);
|
|
|
|
await box.put(BNames.isLoading, false);
|
2022-05-13 13:57:56 +00:00
|
|
|
await box.put(BNames.serverDetails, null);
|
2021-10-13 21:49:24 +00:00
|
|
|
|
2022-12-22 18:45:06 +00:00
|
|
|
final APIGenericResult<void> removalResult = await ApiController
|
|
|
|
.currentDnsProviderApiFactory!
|
2022-11-18 03:07:42 +00:00
|
|
|
.getDnsProvider()
|
|
|
|
.removeSimilarRecords(domain: serverDomain);
|
2022-12-22 18:45:06 +00:00
|
|
|
|
|
|
|
if (!removalResult.success) {
|
|
|
|
getIt<NavigationService>().showSnackBar('modals.dns_removal_error'.tr());
|
|
|
|
}
|
|
|
|
return true;
|
2021-04-22 18:04:24 +00:00
|
|
|
}
|
|
|
|
|
2022-05-31 14:30:35 +00:00
|
|
|
Future<void> deleteServerRelatedRecords() async {
|
2021-04-22 18:04:24 +00:00
|
|
|
await box.deleteAll([
|
2022-05-13 13:57:56 +00:00
|
|
|
BNames.serverDetails,
|
2021-04-22 18:04:24 +00:00
|
|
|
BNames.isServerStarted,
|
|
|
|
BNames.isServerResetedFirstTime,
|
|
|
|
BNames.isServerResetedSecondTime,
|
|
|
|
BNames.hasFinalChecked,
|
|
|
|
BNames.isLoading,
|
|
|
|
]);
|
|
|
|
getIt<ApiConfigModel>().init();
|
|
|
|
}
|
2021-01-21 07:35:38 +00:00
|
|
|
}
|