2022-08-26 19:28:01 +00:00
|
|
|
import 'package:graphql/client.dart';
|
|
|
|
import 'package:selfprivacy/config/get_it_config.dart';
|
2022-11-28 18:51:37 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/api_generic_result.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/api_map.dart';
|
2022-09-05 04:34:47 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/disk_volumes.graphql.dart';
|
2022-08-29 00:40:35 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/schema.graphql.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/server_api.graphql.dart';
|
2022-09-05 04:34:47 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/server_settings.graphql.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/services.graphql.dart';
|
2022-09-04 10:45:03 +00:00
|
|
|
import 'package:selfprivacy/logic/api_maps/graphql_maps/schema/users.graphql.dart';
|
2022-09-14 23:31:25 +00:00
|
|
|
import 'package:selfprivacy/logic/models/auto_upgrade_settings.dart';
|
2022-10-23 01:13:27 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/backblaze_bucket.dart';
|
2022-11-17 07:14:34 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/server_details.dart';
|
2023-05-12 19:32:19 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/server_domain.dart';
|
2022-09-04 10:45:03 +00:00
|
|
|
import 'package:selfprivacy/logic/models/hive/user.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/api_token.dart';
|
2022-10-23 01:13:27 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/backup.dart';
|
|
|
|
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-10-23 01:13:27 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/recovery_token_status.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
import 'package:selfprivacy/logic/models/json/server_disk_volume.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/json/server_job.dart';
|
2022-08-29 00:40:35 +00:00
|
|
|
import 'package:selfprivacy/logic/models/service.dart';
|
2022-09-14 23:31:25 +00:00
|
|
|
import 'package:selfprivacy/logic/models/ssh_settings.dart';
|
|
|
|
import 'package:selfprivacy/logic/models/system_settings.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
export 'package:selfprivacy/logic/api_maps/api_generic_result.dart';
|
|
|
|
|
2022-08-26 19:28:01 +00:00
|
|
|
part 'jobs_api.dart';
|
|
|
|
part 'server_actions_api.dart';
|
|
|
|
part 'services_api.dart';
|
2022-09-04 10:45:03 +00:00
|
|
|
part 'users_api.dart';
|
2022-09-05 04:34:47 +00:00
|
|
|
part 'volume_api.dart';
|
2022-08-26 19:28:01 +00:00
|
|
|
|
2022-08-29 20:35:06 +00:00
|
|
|
class ServerApi extends ApiMap
|
2022-09-05 04:34:47 +00:00
|
|
|
with VolumeApi, JobsApi, ServerActionsApi, ServicesApi, UsersApi {
|
2022-08-26 19:28:01 +00:00
|
|
|
ServerApi({
|
|
|
|
this.hasLogger = false,
|
|
|
|
this.isWithToken = true,
|
|
|
|
this.customToken = '',
|
2022-10-23 01:13:27 +00:00
|
|
|
this.overrideDomain,
|
2022-09-09 14:57:34 +00:00
|
|
|
});
|
|
|
|
|
2022-08-26 19:28:01 +00:00
|
|
|
@override
|
|
|
|
bool hasLogger;
|
|
|
|
@override
|
|
|
|
bool isWithToken;
|
|
|
|
@override
|
|
|
|
String customToken;
|
|
|
|
@override
|
2022-10-23 01:13:27 +00:00
|
|
|
String? get rootAddress =>
|
|
|
|
overrideDomain ?? getIt<ApiConfigModel>().serverDomain?.domainName;
|
|
|
|
String? overrideDomain;
|
2022-08-26 19:28:01 +00:00
|
|
|
|
|
|
|
Future<String?> getApiVersion() async {
|
|
|
|
QueryResult response;
|
|
|
|
String? apiVersion;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$GetApiVersion();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
|
|
|
apiVersion = response.data!['api']['version'];
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
return apiVersion;
|
|
|
|
}
|
|
|
|
|
2022-11-17 07:14:34 +00:00
|
|
|
Future<ServerProvider> getServerProviderType() async {
|
2022-11-23 07:55:28 +00:00
|
|
|
QueryResult<Query$SystemServerProvider> response;
|
2022-11-17 07:14:34 +00:00
|
|
|
ServerProvider providerType = ServerProvider.unknown;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$SystemServerProvider();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
2022-11-23 07:55:28 +00:00
|
|
|
providerType = ServerProvider.fromGraphQL(
|
|
|
|
response.parsedData!.system.provider.provider,
|
|
|
|
);
|
2022-11-17 07:14:34 +00:00
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
return providerType;
|
|
|
|
}
|
|
|
|
|
2023-05-12 19:32:19 +00:00
|
|
|
Future<DnsProvider> getDnsProviderType() async {
|
|
|
|
QueryResult<Query$SystemDnsProvider> response;
|
|
|
|
DnsProvider providerType = DnsProvider.unknown;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$SystemDnsProvider();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
|
|
|
providerType = DnsProvider.fromGraphQL(
|
|
|
|
response.parsedData!.system.domainInfo.provider,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
return providerType;
|
|
|
|
}
|
|
|
|
|
2022-09-02 05:59:46 +00:00
|
|
|
Future<bool> isUsingBinds() async {
|
|
|
|
QueryResult response;
|
|
|
|
bool usesBinds = false;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$SystemIsUsingBinds();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
|
|
|
usesBinds = response.data!['system']['info']['usingBinds'];
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
return usesBinds;
|
|
|
|
}
|
|
|
|
|
2022-08-26 19:28:01 +00:00
|
|
|
Future<void> switchService(final String uid, final bool needTurnOn) async {
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
if (needTurnOn) {
|
|
|
|
final variables = Variables$Mutation$EnableService(serviceId: uid);
|
|
|
|
final mutation = Options$Mutation$EnableService(variables: variables);
|
|
|
|
await client.mutate$EnableService(mutation);
|
|
|
|
} else {
|
|
|
|
final variables = Variables$Mutation$DisableService(serviceId: uid);
|
|
|
|
final mutation = Options$Mutation$DisableService(variables: variables);
|
|
|
|
await client.mutate$DisableService(mutation);
|
|
|
|
}
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
}
|
2022-09-12 17:38:22 +00:00
|
|
|
|
|
|
|
Future<void> setAutoUpgradeSettings(
|
2022-09-14 23:31:25 +00:00
|
|
|
final AutoUpgradeSettings settings,
|
2022-09-12 17:38:22 +00:00
|
|
|
) async {
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
final input = Input$AutoUpgradeSettingsInput(
|
2022-09-14 23:31:25 +00:00
|
|
|
allowReboot: settings.allowReboot,
|
|
|
|
enableAutoUpgrade: settings.enable,
|
2022-09-12 17:38:22 +00:00
|
|
|
);
|
|
|
|
final variables = Variables$Mutation$ChangeAutoUpgradeSettings(
|
|
|
|
settings: input,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$ChangeAutoUpgradeSettings(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
await client.mutate$ChangeAutoUpgradeSettings(mutation);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
}
|
2022-09-14 23:31:25 +00:00
|
|
|
|
|
|
|
Future<void> setTimezone(final String timezone) async {
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
final variables = Variables$Mutation$ChangeTimezone(
|
|
|
|
timezone: timezone,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$ChangeTimezone(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
await client.mutate$ChangeTimezone(mutation);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<SystemSettings> getSystemSettings() async {
|
|
|
|
QueryResult<Query$SystemSettings> response;
|
|
|
|
SystemSettings settings = SystemSettings(
|
|
|
|
autoUpgradeSettings: AutoUpgradeSettings(
|
|
|
|
allowReboot: false,
|
|
|
|
enable: false,
|
|
|
|
),
|
|
|
|
sshSettings: SshSettings(
|
|
|
|
enable: false,
|
|
|
|
passwordAuthentication: false,
|
|
|
|
),
|
|
|
|
timezone: 'Unknown',
|
|
|
|
);
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$SystemSettings();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
|
|
|
settings = SystemSettings.fromGraphQL(response.parsedData!.system);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
return settings;
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<RecoveryKeyStatus?>> getRecoveryTokenStatus() async {
|
2022-10-24 09:47:47 +00:00
|
|
|
RecoveryKeyStatus? key;
|
|
|
|
QueryResult<Query$RecoveryKey> response;
|
|
|
|
String? error;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$RecoveryKey();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
error = response.exception.toString();
|
|
|
|
}
|
|
|
|
key = RecoveryKeyStatus.fromGraphQL(response.parsedData!.api.recoveryKey);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
return APIGenericResult<RecoveryKeyStatus?>(
|
2022-10-24 09:47:47 +00:00
|
|
|
success: error == null,
|
|
|
|
data: key,
|
|
|
|
message: error,
|
|
|
|
);
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<String>> generateRecoveryToken(
|
2022-10-23 01:13:27 +00:00
|
|
|
final DateTime? expirationDate,
|
|
|
|
final int? numberOfUses,
|
2022-10-24 09:47:47 +00:00
|
|
|
) async {
|
2022-11-28 18:51:37 +00:00
|
|
|
APIGenericResult<String> key;
|
2022-10-24 09:47:47 +00:00
|
|
|
QueryResult<Mutation$GetNewRecoveryApiKey> response;
|
|
|
|
|
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
|
|
|
|
final input = Input$RecoveryKeyLimitsInput(
|
|
|
|
expirationDate: expirationDate,
|
|
|
|
uses: numberOfUses,
|
|
|
|
);
|
|
|
|
final variables = Variables$Mutation$GetNewRecoveryApiKey(
|
|
|
|
limits: input,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$GetNewRecoveryApiKey(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
response = await client.mutate$GetNewRecoveryApiKey(
|
|
|
|
mutation,
|
|
|
|
);
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
2022-11-28 18:51:37 +00:00
|
|
|
key = APIGenericResult<String>(
|
2022-10-24 09:47:47 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: response.exception.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
key = APIGenericResult<String>(
|
2022-10-24 09:47:47 +00:00
|
|
|
success: true,
|
|
|
|
data: response.parsedData!.getNewRecoveryApiKey.key!,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
key = APIGenericResult<String>(
|
2022-10-24 09:47:47 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-30 14:21:38 +00:00
|
|
|
Future<List<DnsRecord>> getDnsRecords() async {
|
|
|
|
List<DnsRecord> records = [];
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Query$DomainInfo> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$DomainInfo();
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
|
|
|
}
|
2022-10-30 14:21:38 +00:00
|
|
|
records = response.parsedData!.system.domainInfo.requiredDnsRecords
|
|
|
|
.map<DnsRecord>(
|
|
|
|
(final Fragment$dnsRecordFields fragment) =>
|
|
|
|
DnsRecord.fromGraphQL(fragment),
|
2022-10-24 11:39:53 +00:00
|
|
|
)
|
2022-10-30 14:21:38 +00:00
|
|
|
.toList();
|
2022-10-24 11:39:53 +00:00
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-30 14:21:38 +00:00
|
|
|
return records;
|
2022-10-24 11:39:53 +00:00
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<List<ApiToken>>> getApiTokens() async {
|
|
|
|
APIGenericResult<List<ApiToken>> tokens;
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Query$GetApiTokens> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
response = await client.query$GetApiTokens();
|
|
|
|
if (response.hasException) {
|
|
|
|
final message = response.exception.toString();
|
|
|
|
print(message);
|
2022-11-28 18:51:37 +00:00
|
|
|
tokens = APIGenericResult<List<ApiToken>>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: [],
|
|
|
|
message: message,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
final List<ApiToken> parsed = response.parsedData!.api.devices
|
|
|
|
.map(
|
|
|
|
(
|
|
|
|
final Query$GetApiTokens$api$devices device,
|
|
|
|
) =>
|
|
|
|
ApiToken.fromGraphQL(device),
|
|
|
|
)
|
|
|
|
.toList();
|
2022-11-28 18:51:37 +00:00
|
|
|
tokens = APIGenericResult<List<ApiToken>>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: true,
|
|
|
|
data: parsed,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
tokens = APIGenericResult<List<ApiToken>>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: [],
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
return tokens;
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<void>> deleteApiToken(final String name) async {
|
|
|
|
APIGenericResult<void> returnable;
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Mutation$DeleteDeviceApiToken> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
final variables = Variables$Mutation$DeleteDeviceApiToken(
|
|
|
|
device: name,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$DeleteDeviceApiToken(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
response = await client.mutate$DeleteDeviceApiToken(
|
|
|
|
mutation,
|
|
|
|
);
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
2022-11-28 18:51:37 +00:00
|
|
|
returnable = APIGenericResult<void>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: null,
|
|
|
|
message: response.exception.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
returnable = APIGenericResult<void>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: true,
|
|
|
|
data: null,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
returnable = APIGenericResult<void>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: null,
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
return returnable;
|
|
|
|
}
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<String>> createDeviceToken() async {
|
|
|
|
APIGenericResult<String> token;
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Mutation$GetNewDeviceApiKey> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
final mutation = Options$Mutation$GetNewDeviceApiKey();
|
|
|
|
response = await client.mutate$GetNewDeviceApiKey(
|
|
|
|
mutation,
|
|
|
|
);
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: response.exception.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: true,
|
|
|
|
data: response.parsedData!.getNewDeviceApiKey.key!,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<bool> isHttpServerWorking() async => (await getApiVersion()) != null;
|
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<String>> authorizeDevice(
|
2022-10-24 11:39:53 +00:00
|
|
|
final DeviceToken deviceToken,
|
|
|
|
) async {
|
2022-11-28 18:51:37 +00:00
|
|
|
APIGenericResult<String> token;
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Mutation$AuthorizeWithNewDeviceApiKey> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
|
|
|
|
final input = Input$UseNewDeviceKeyInput(
|
|
|
|
deviceName: deviceToken.device,
|
|
|
|
key: deviceToken.token,
|
|
|
|
);
|
|
|
|
|
|
|
|
final variables = Variables$Mutation$AuthorizeWithNewDeviceApiKey(
|
|
|
|
input: input,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$AuthorizeWithNewDeviceApiKey(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
response = await client.mutate$AuthorizeWithNewDeviceApiKey(
|
|
|
|
mutation,
|
|
|
|
);
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: response.exception.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: true,
|
|
|
|
data: response.parsedData!.authorizeWithNewDeviceApiKey.token!,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
2022-11-28 18:51:37 +00:00
|
|
|
Future<APIGenericResult<String>> useRecoveryToken(
|
2022-10-24 11:39:53 +00:00
|
|
|
final DeviceToken deviceToken,
|
|
|
|
) async {
|
2022-11-28 18:51:37 +00:00
|
|
|
APIGenericResult<String> token;
|
2022-10-24 11:39:53 +00:00
|
|
|
QueryResult<Mutation$UseRecoveryApiKey> response;
|
2022-10-23 01:13:27 +00:00
|
|
|
|
2022-10-24 11:39:53 +00:00
|
|
|
try {
|
|
|
|
final GraphQLClient client = await getClient();
|
|
|
|
|
|
|
|
final input = Input$UseRecoveryKeyInput(
|
|
|
|
deviceName: deviceToken.device,
|
|
|
|
key: deviceToken.token,
|
|
|
|
);
|
|
|
|
|
|
|
|
final variables = Variables$Mutation$UseRecoveryApiKey(
|
|
|
|
input: input,
|
|
|
|
);
|
|
|
|
final mutation = Options$Mutation$UseRecoveryApiKey(
|
|
|
|
variables: variables,
|
|
|
|
);
|
|
|
|
response = await client.mutate$UseRecoveryApiKey(
|
|
|
|
mutation,
|
|
|
|
);
|
|
|
|
if (response.hasException) {
|
|
|
|
print(response.exception.toString());
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: response.exception.toString(),
|
|
|
|
);
|
|
|
|
}
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: true,
|
|
|
|
data: response.parsedData!.useRecoveryApiKey.token!,
|
|
|
|
);
|
|
|
|
} catch (e) {
|
|
|
|
print(e);
|
2022-11-28 18:51:37 +00:00
|
|
|
token = APIGenericResult<String>(
|
2022-10-24 11:39:53 +00:00
|
|
|
success: false,
|
|
|
|
data: '',
|
|
|
|
message: e.toString(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// TODO: backups're not implemented on server side
|
|
|
|
|
|
|
|
Future<BackupStatus> getBackupStatus() async => BackupStatus(
|
|
|
|
progress: 0.0,
|
|
|
|
status: BackupStatusEnum.error,
|
|
|
|
errorMessage: null,
|
|
|
|
);
|
|
|
|
|
|
|
|
Future<List<Backup>> getBackups() async => [];
|
|
|
|
|
|
|
|
Future<void> uploadBackblazeConfig(final BackblazeBucket bucket) async {}
|
|
|
|
|
|
|
|
Future<void> forceBackupListReload() async {}
|
|
|
|
|
|
|
|
Future<void> startBackup() async {}
|
|
|
|
|
|
|
|
Future<void> restoreBackup(final String backupId) async {}
|
2022-08-26 19:28:01 +00:00
|
|
|
}
|