mirror of
https://github.com/JGeek00/adguard-home-manager.git
synced 2025-04-21 22:39:11 +00:00
2273 lines
No EOL
58 KiB
Dart
2273 lines
No EOL
58 KiB
Dart
// ignore_for_file: depend_on_referenced_packages
|
|
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
|
|
import 'package:adguard_home_manager/models/blocked_services.dart';
|
|
import 'package:adguard_home_manager/models/dhcp.dart';
|
|
import 'package:adguard_home_manager/models/dns_info.dart';
|
|
import 'package:adguard_home_manager/models/encryption.dart';
|
|
import 'package:adguard_home_manager/models/filtering.dart';
|
|
import 'package:adguard_home_manager/models/github_release.dart';
|
|
import 'package:adguard_home_manager/models/logs.dart';
|
|
import 'package:adguard_home_manager/models/filtering_status.dart';
|
|
import 'package:adguard_home_manager/models/app_log.dart';
|
|
import 'package:adguard_home_manager/models/rewrite_rules.dart';
|
|
import 'package:adguard_home_manager/models/server_info.dart';
|
|
import 'package:adguard_home_manager/models/server_status.dart';
|
|
import 'package:adguard_home_manager/models/clients.dart';
|
|
import 'package:adguard_home_manager/models/clients_allowed_blocked.dart';
|
|
import 'package:adguard_home_manager/models/server.dart';
|
|
import 'package:adguard_home_manager/constants/urls.dart';
|
|
|
|
|
|
Future<Map<String, dynamic>> apiRequest({
|
|
required Server server,
|
|
required String method,
|
|
required String urlPath,
|
|
dynamic body,
|
|
required String type,
|
|
bool? overrideTimeout,
|
|
}) async {
|
|
final String connectionString = "${server.connectionMethod}://${server.domain}${server.port != null ? ':${server.port}' : ""}${server.path ?? ""}/control$urlPath";
|
|
try {
|
|
HttpClient httpClient = HttpClient();
|
|
if (method == 'get') {
|
|
HttpClientRequest request = await httpClient.getUrl(Uri.parse(connectionString));
|
|
if (server.authToken != null) {
|
|
request.headers.set('Authorization', 'Basic ${server.authToken}');
|
|
}
|
|
HttpClientResponse response = overrideTimeout == true
|
|
? await request.close()
|
|
: await request.close().timeout(const Duration(seconds: 10));
|
|
String reply = await response.transform(utf8.decoder).join();
|
|
httpClient.close();
|
|
if (response.statusCode == 200) {
|
|
return {
|
|
'hasResponse': true,
|
|
'error': false,
|
|
'statusCode': response.statusCode,
|
|
'body': reply
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'hasResponse': true,
|
|
'error': true,
|
|
'statusCode': response.statusCode,
|
|
'body': reply
|
|
};
|
|
}
|
|
}
|
|
else if (method == 'post' || method == 'put') {
|
|
HttpClientRequest? request;
|
|
if (method == 'post') {
|
|
request = await httpClient.postUrl(Uri.parse(connectionString));
|
|
}
|
|
else if (method == 'put') {
|
|
request = await httpClient.putUrl(Uri.parse(connectionString));
|
|
}
|
|
else {
|
|
return {
|
|
'hasResponse': false,
|
|
'error': true,
|
|
'statusCode': null,
|
|
'body': 'Invalid method [selected $method]'
|
|
};
|
|
}
|
|
|
|
if (server.authToken != null) {
|
|
request.headers.set('Authorization', 'Basic ${server.authToken}');
|
|
}
|
|
request.headers.set('content-type', 'application/json');
|
|
request.add(utf8.encode(json.encode(body)));
|
|
HttpClientResponse response = overrideTimeout == true
|
|
? await request.close()
|
|
: await request.close().timeout(const Duration(seconds: 10));
|
|
String reply = await response.transform(utf8.decoder).join();
|
|
httpClient.close();
|
|
if (response.statusCode == 200) {
|
|
return {
|
|
'hasResponse': true,
|
|
'error': false,
|
|
'statusCode': response.statusCode,
|
|
'body': reply
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'hasResponse': true,
|
|
'error': true,
|
|
'statusCode': response.statusCode,
|
|
'body': reply
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
throw Exception('Method is required');
|
|
}
|
|
} on SocketException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'SocketException',
|
|
'log': AppLog(
|
|
type: type,
|
|
dateTime: DateTime.now(),
|
|
message: 'SocketException'
|
|
)
|
|
};
|
|
} on TimeoutException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'TimeoutException',
|
|
'log': AppLog(
|
|
type: type,
|
|
dateTime: DateTime.now(),
|
|
message: 'TimeoutException'
|
|
)
|
|
};
|
|
} on HandshakeException {
|
|
return {
|
|
'result': 'ssl_error',
|
|
'message': 'HandshakeException',
|
|
'log': AppLog(
|
|
type: type,
|
|
dateTime: DateTime.now(),
|
|
message: 'HandshakeException'
|
|
)
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
'result': 'error',
|
|
'message': e.toString(),
|
|
'log': AppLog(
|
|
type: type,
|
|
dateTime: DateTime.now(),
|
|
message: e.toString()
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future login(Server server) async {
|
|
final result = await apiRequest(
|
|
server: server,
|
|
method: 'post',
|
|
urlPath: '/login',
|
|
body: {
|
|
"name": server.user,
|
|
"password": server.password
|
|
},
|
|
type: 'login'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else if (result['statusCode'] == 400 || result['statusCode'] == 401 || result['statusCode'] == 403) {
|
|
return {
|
|
'result': 'invalid_username_password',
|
|
'log': AppLog(
|
|
type: 'login',
|
|
dateTime: DateTime.now(),
|
|
message: 'invalid_username_password',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
else if (result['statusCode'] == 429) {
|
|
return {
|
|
'result': 'many_attempts',
|
|
'log': AppLog(
|
|
type: 'login',
|
|
dateTime: DateTime.now(),
|
|
message: 'many_attempts',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
else if (result['statusCode'] == 500) {
|
|
return {
|
|
'result': 'server_error',
|
|
'log': AppLog(
|
|
type: 'login',
|
|
dateTime: DateTime.now(),
|
|
message: 'server_error',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'login',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future loginHA(Server server) async {
|
|
final result = await apiRequest(
|
|
server: server,
|
|
method: 'get',
|
|
urlPath: '/status',
|
|
type: 'login_ha'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else if (result['statusCode'] == 401 || result['statusCode'] == 403) {
|
|
return {
|
|
'result': 'invalid_username_password',
|
|
'log': AppLog(
|
|
type: 'login',
|
|
dateTime: DateTime.now(),
|
|
message: 'invalid_username_password',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'login_ha',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class ApiClient {
|
|
final Server server;
|
|
|
|
ApiClient({
|
|
required this.server
|
|
});
|
|
|
|
Future getServerVersion() async {
|
|
final result = await apiRequest(
|
|
server: server,
|
|
method: 'get',
|
|
urlPath: '/status',
|
|
type: 'get_server_version'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200 && result['body'] != null) {
|
|
return {
|
|
'result': 'success',
|
|
'data': jsonDecode(result['body'])['version']
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_server_version',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getServerStatus() async {
|
|
final result = await Future.wait([
|
|
apiRequest(server: server, method: 'get', urlPath: '/stats', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/status', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/filtering/status', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/safesearch/status', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/safebrowsing/status', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/parental/status', type: 'server_status'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/clients', type: 'server_status'),
|
|
]);
|
|
|
|
if (
|
|
result[0]['hasResponse'] == true &&
|
|
result[1]['hasResponse'] == true &&
|
|
result[2]['hasResponse'] == true &&
|
|
result[3]['hasResponse'] == true &&
|
|
result[4]['hasResponse'] == true &&
|
|
result[5]['hasResponse'] == true &&
|
|
result[6]['hasResponse'] == true
|
|
) {
|
|
if (
|
|
result[0]['statusCode'] == 200 &&
|
|
result[1]['statusCode'] == 200 &&
|
|
result[2]['statusCode'] == 200 &&
|
|
result[3]['statusCode'] == 200 &&
|
|
result[4]['statusCode'] == 200 &&
|
|
result[5]['statusCode'] == 200 &&
|
|
result[6]['statusCode'] == 200
|
|
) {
|
|
final Map<String, dynamic> mappedData = {
|
|
'stats': jsonDecode(result[0]['body']),
|
|
'clients': jsonDecode(result[6]['body'])['clients'],
|
|
'status': jsonDecode(result[1]['body']),
|
|
'filtering': jsonDecode(result[2]['body']),
|
|
'safeSearch': jsonDecode(result[3]['body']),
|
|
'safeBrowsingEnabled': jsonDecode(result[4]['body']),
|
|
'parentalControlEnabled': jsonDecode(result[5]['body']),
|
|
};
|
|
return {
|
|
'result': 'success',
|
|
'data': ServerStatus.fromJson(mappedData)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_server_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode']).toString(),
|
|
resBody: result.map((res) => res['body']).toString()
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_server_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'no_response',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString()
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future updateFiltering({
|
|
required bool enable,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/config',
|
|
method: 'post',
|
|
server: server,
|
|
body: {
|
|
'enabled': enable
|
|
},
|
|
type: 'update_filtering'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_filtering',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateSafeSearchLegacy(bool enable) async {
|
|
final result = enable == true
|
|
? await apiRequest(
|
|
urlPath: '/safesearch/enable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'enable_safe_search'
|
|
)
|
|
: await apiRequest(
|
|
urlPath: '/safesearch/disable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'disable_safe_search'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'safe_search',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateSafeBrowsing(bool enable) async {
|
|
final result = enable == true
|
|
? await apiRequest(
|
|
urlPath: '/safebrowsing/enable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'enable_safe_browsing'
|
|
)
|
|
: await apiRequest(
|
|
urlPath: '/safebrowsing/disable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'disable_safe_browsing'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'safe_browsing',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateParentalControl(bool enable) async {
|
|
final result = enable == true
|
|
? await apiRequest(
|
|
urlPath: '/parental/enable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'enable_parental_control'
|
|
)
|
|
: await apiRequest(
|
|
urlPath: '/parental/disable',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'disable_parental_control'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'parental_control',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateGeneralProtection({
|
|
required bool enable,
|
|
int? time
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/protection',
|
|
method: 'post',
|
|
server: server,
|
|
body: {
|
|
'enabled': enable,
|
|
'duration': time
|
|
},
|
|
type: 'general_protection'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'general_protection',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateGeneralProtectionLegacy(bool enable) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dns_config',
|
|
method: 'post',
|
|
server: server,
|
|
body: {
|
|
'protection_enabled': enable
|
|
},
|
|
type: 'general_protection'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'general_protection',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getClients() async {
|
|
final result = await Future.wait([
|
|
apiRequest(server: server, method: 'get', urlPath: '/clients', type: 'get_clients'),
|
|
apiRequest(server: server, method: 'get', urlPath: '/access/list', type: 'get_clients'),
|
|
]);
|
|
|
|
if (result[0]['hasResponse'] == true && result[1]['hasResponse'] == true) {
|
|
if (result[0]['statusCode'] == 200 && result[1]['statusCode'] == 200) {
|
|
final clients = Clients.fromJson(jsonDecode(result[0]['body']));
|
|
clients.clientsAllowedBlocked = ClientsAllowedBlocked.fromJson(jsonDecode(result[1]['body']));
|
|
return {
|
|
'result': 'success',
|
|
'data': clients
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_clients',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_clients',
|
|
dateTime: DateTime.now(),
|
|
message: 'no_response',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future requestAllowedBlockedClientsHosts(Map<String, List<String>?> body) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/access/set',
|
|
method: 'post',
|
|
server: server,
|
|
body: body,
|
|
type: 'get_clients'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
if (result['statusCode'] == 400) {
|
|
return {
|
|
'result': 'error',
|
|
'message': 'client_another_list'
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_clients',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getLogs({
|
|
required int count,
|
|
int? offset,
|
|
DateTime? olderThan,
|
|
String? responseStatus,
|
|
String? search
|
|
}) async {
|
|
final result = await apiRequest(
|
|
server: server,
|
|
method: 'get',
|
|
urlPath: '/querylog?limit=$count${offset != null ? '&offset=$offset' : ''}${olderThan != null ? '&older_than=${olderThan.toIso8601String()}' : ''}${responseStatus != null ? '&response_status=$responseStatus' : ''}${search != null ? '&search=$search' : ''}',
|
|
type: 'get_logs'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': LogsData.fromJson(jsonDecode(result['body']))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_logs',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getFilteringRules() async {
|
|
final result = await apiRequest(
|
|
server: server,
|
|
method: 'get',
|
|
urlPath: '/filtering/status',
|
|
type: 'get_filtering_rules'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': FilteringStatus.fromJson(jsonDecode(result['body']))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_filtering_rules',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future postFilteringRules({
|
|
required Map<String, List<String>> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/set_rules',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'post_filering_rules'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'post_filtering_rules',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future postAddClient({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/clients/add',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'add_client'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'add_client',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future postUpdateClient({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/clients/update',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_client'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_client',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future postDeleteClient({
|
|
required String name,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/clients/delete',
|
|
method: 'post',
|
|
server: server,
|
|
body: {'name': name},
|
|
type: 'remove_client'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'remove_client',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getFiltering() async {
|
|
final result = await Future.wait([
|
|
apiRequest(
|
|
urlPath: '/filtering/status',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_filtering_status'
|
|
),
|
|
apiRequest(
|
|
urlPath: '/blocked_services/list',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_filtering_status'
|
|
),
|
|
]);
|
|
|
|
if (result[0]['hasResponse'] == true && result[0]['hasResponse'] == true) {
|
|
if (result[0]['statusCode'] == 200 && result[0]['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': Filtering.fromJson({
|
|
...jsonDecode(result[0]['body']),
|
|
"blocked_services": result[1]['body'] != null
|
|
? jsonDecode(result[1]['body'])
|
|
: []
|
|
})
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_filtering_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_filtering_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'no_response',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future setCustomRules({
|
|
required List<String> rules,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/set_rules',
|
|
method: 'post',
|
|
server: server,
|
|
body: {'rules': rules},
|
|
type: 'set_custom_rules'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'set_custom_rules',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
|
|
}
|
|
|
|
Future addFilteringList({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/add_url',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'add_filtering_url'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': result['body']
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'add_filtering_url',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateFilterList({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/set_url',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_filter_list'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_filter_list',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future deleteFilterList({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/remove_url',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'delete_filter_list'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'delete_filter_list',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getServerInfo() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/status',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'server_info'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': ServerInfoData.fromJson(jsonDecode(result['body']))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'server_info',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body']
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateLists() async {
|
|
final result = await Future.wait([
|
|
apiRequest(
|
|
urlPath: '/filtering/refresh',
|
|
method: 'post',
|
|
server: server,
|
|
body: {'whitelist': true},
|
|
type: 'update_lists',
|
|
overrideTimeout: true
|
|
),
|
|
apiRequest(
|
|
urlPath: '/filtering/refresh',
|
|
method: 'post',
|
|
server: server,
|
|
body: {'whitelist': false},
|
|
type: 'update_lists',
|
|
overrideTimeout: true
|
|
),
|
|
]);
|
|
|
|
if (result[0]['hasResponse'] == true && result[1]['hasResponse'] == true) {
|
|
if (result[0]['statusCode'] == 200 && result[1]['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': {'updated': jsonDecode(result[0]['body'])['updated']+jsonDecode(result[1]['body'])['updated']}
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_lists',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_lists',
|
|
dateTime: DateTime.now(),
|
|
message: [result[0]['message'], result[1]['message']].toString(),
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future checkHostFiltered({
|
|
required String host,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/check_host?name=$host',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'check_host_filtered'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': jsonDecode(result['body'])
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_lists',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future requestChangeUpdateFrequency({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/filtering/config',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'change_update_frequency'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'change_update_frequency',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future setBlockedServices({
|
|
required List<String> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/blocked_services/set',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_blocked_services'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_blocked_services',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getDhcpData() async {
|
|
final result = await Future.wait([
|
|
apiRequest(
|
|
urlPath: '/dhcp/interfaces',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_dhcp_data'
|
|
),
|
|
apiRequest(
|
|
urlPath: '/dhcp/status',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_dhcp_data'
|
|
),
|
|
]);
|
|
|
|
if (result[0]['hasResponse'] == true && result[1]['hasResponse'] == true) {
|
|
if (result[0]['statusCode'] == 200 && result[1]['statusCode'] == 200) {
|
|
List<NetworkInterface> interfaces = List<NetworkInterface>.from(jsonDecode(result[0]['body']).entries.map((entry) => NetworkInterface.fromJson(entry.value)));
|
|
|
|
return {
|
|
'result': 'success',
|
|
'data': DhcpModel(
|
|
networkInterfaces: interfaces,
|
|
dhcpStatus: DhcpStatus.fromJson(jsonDecode(result[1]['body']))
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_dhcp_data',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_dhpc_data',
|
|
dateTime: DateTime.now(),
|
|
message: [result[0]['log'].message, result[1]['log'].message].toString(),
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future saveDhcpConfig({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dhcp/set_config',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'save_dhcp_config'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'save_dhcp_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future resetDhcpConfig() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dhcp/reset',
|
|
method: 'post',
|
|
server: server,
|
|
body: {},
|
|
type: 'reset_dhcp_config'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'reset_dhcp_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future deleteStaticLease({
|
|
required Map<String, dynamic> data
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dhcp/remove_static_lease',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'remove_static_lease'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'remove_static_lease',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future createStaticLease({
|
|
required Map<String, dynamic> data
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dhcp/add_static_lease',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'add_static_lease'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else if (result['statusCode'] == 400 && result['body'].contains('static lease already exists')) {
|
|
return {
|
|
'result': 'error',
|
|
'message': 'already_exists',
|
|
'log': AppLog(
|
|
type: 'add_static_lease',
|
|
dateTime: DateTime.now(),
|
|
message: 'already_exists',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
else if (result['statusCode'] == 400 && result['body'].contains('server is unconfigured')) {
|
|
return {
|
|
'result': 'error',
|
|
'message': 'server_not_configured',
|
|
'log': AppLog(
|
|
type: 'add_static_lease',
|
|
dateTime: DateTime.now(),
|
|
message: 'server_not_configured',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'add_static_lease',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future restoreAllLeases() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dhcp/reset_leases',
|
|
method: 'post',
|
|
server: server,
|
|
body: {},
|
|
type: 'restore_all_leases'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {'result': 'success'};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'restore_all_leases',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getDnsRewriteRules() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/rewrite/list',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_dns_rewrite_rules'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
final List<RewriteRules> data = List<RewriteRules>.from(
|
|
jsonDecode(result['body']).map((item) => RewriteRules.fromJson(item))
|
|
);
|
|
|
|
return {
|
|
'result': 'success',
|
|
'data': data
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_dns_rewrite_rules',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future deleteDnsRewriteRule({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/rewrite/delete',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'delete_dns_rewrite_rule'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'delete_dns_rewrite_rule',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future addDnsRewriteRule({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/rewrite/add',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'add_dns_rewrite_rule'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'add_dns_rewrite_rule',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getQueryLogInfo() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/querylog/config',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_query_log_info'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': jsonDecode(result['body'])
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_query_log_info',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getQueryLogInfoLegacy() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/querylog_info',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_query_log_info'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': jsonDecode(result['body'])
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_query_log_info',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateQueryLogParameters({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/querylog/config/update',
|
|
method: 'put',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_query_log_config'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_query_log_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateQueryLogParametersLegacy({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/querylog_config',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_query_log_config'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_query_log_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future clearLogs() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/querylog_clear',
|
|
method: 'post',
|
|
server: server,
|
|
body: {},
|
|
type: 'clear_query_logs'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'clear_query_logs',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getDnsInfo() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dns_info',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_dns_info'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success' ,
|
|
'data': DnsInfo.fromJson(jsonDecode(result['body']))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_dns_info',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future setDnsConfig({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/dns_config',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'set_dns_config'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
if (result['statusCode'] == 400) {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'set_dns_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'data_not_valid',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'set_dns_config',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getEncryptionSettings() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/tls/status',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_encryption_settings'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': EncryptionData.fromJson(jsonDecode(result['body']))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future getBlockedServices() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/blocked_services/all',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'get_blocked_services'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': List<BlockedService>.from(
|
|
BlockedServicesFromApi.fromJson(jsonDecode(result['body'])).blockedServices
|
|
)
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future checkEncryptionSettings({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/tls/validate',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'check_encryption_settings'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'data': jsonDecode(result['body'])
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'check_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future saveEncryptionSettings({
|
|
required Map<String, dynamic> data,
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/tls/configure',
|
|
method: 'post',
|
|
server: server,
|
|
body: data,
|
|
type: 'update_encryption_settings'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future resetDnsCache() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/cache_clear',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'clear_dns_cache'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'clear_dns_cache',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future checkServerUpdates() async {
|
|
final result = await Future.wait([
|
|
apiRequest(
|
|
urlPath: '/version.json',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'check_server_updates',
|
|
body: json.encode({
|
|
"recheck_now": true
|
|
})
|
|
),
|
|
apiRequest(
|
|
urlPath: '/status',
|
|
method: 'get',
|
|
server: server,
|
|
type: 'check_server_updates',
|
|
body: json.encode({
|
|
"recheck_now": true
|
|
})
|
|
),
|
|
]);
|
|
|
|
if (result[0]['hasResponse'] == true && result[1]['hasResponse'] == true) {
|
|
if (result[0]['statusCode'] == 200 && result[1]['statusCode'] == 200) {
|
|
final Map<String, dynamic> obj = {
|
|
...jsonDecode(result[0]['body']),
|
|
'current_version': ServerInfoData.fromJson(jsonDecode(result[1]['body'])).version
|
|
};
|
|
return {
|
|
'result': 'success',
|
|
'data': obj
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_filtering_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'get_filtering_status',
|
|
dateTime: DateTime.now(),
|
|
message: 'no_response',
|
|
statusCode: result.map((res) => res['statusCode'] ?? 'null').toString(),
|
|
resBody: result.map((res) => res['body'] ?? 'null').toString(),
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future getUpdateChangelog({
|
|
required String releaseTag
|
|
}) async {
|
|
try {
|
|
HttpClient httpClient = HttpClient();
|
|
HttpClientRequest request = await httpClient.getUrl(Uri.parse("${Urls.adGuardHomeReleasesTags}/$releaseTag"));
|
|
HttpClientResponse response = await request.close();
|
|
String reply = await response.transform(utf8.decoder).join();
|
|
httpClient.close();
|
|
if (response.statusCode == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'hasResponse': true,
|
|
'error': false,
|
|
'statusCode': response.statusCode,
|
|
'body': jsonDecode(reply)['body']
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: response.statusCode.toString(),
|
|
resBody: reply,
|
|
)
|
|
};
|
|
}
|
|
} on SocketException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'SocketException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'SocketException'
|
|
)
|
|
};
|
|
} on TimeoutException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'TimeoutException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'TimeoutException'
|
|
)
|
|
};
|
|
} on HandshakeException {
|
|
return {
|
|
'result': 'ssl_error',
|
|
'message': 'HandshakeException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'HandshakeException'
|
|
)
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
'result': 'error',
|
|
'message': e.toString(),
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: e.toString()
|
|
)
|
|
};
|
|
}
|
|
}
|
|
|
|
Future requestUpdateServer() async {
|
|
final result = await apiRequest(
|
|
urlPath: '/update',
|
|
method: 'post',
|
|
server: server,
|
|
type: 'update_server'
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_server',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
Future updateSafeSearchSettings({
|
|
|
|
required Map<String, bool> body
|
|
}) async {
|
|
final result = await apiRequest(
|
|
urlPath: '/safesearch/settings',
|
|
method: 'put',
|
|
server: server,
|
|
type: 'safesearch_settings',
|
|
body: body
|
|
);
|
|
|
|
if (result['hasResponse'] == true) {
|
|
if (result['statusCode'] == 200) {
|
|
return { 'result': 'success' };
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'safesearch_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: result['statusCode'].toString(),
|
|
resBody: result['body'],
|
|
)
|
|
};
|
|
}
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
Future checkAppUpdatesGitHub() async {
|
|
try {
|
|
HttpClient httpClient = HttpClient();
|
|
HttpClientRequest request = await httpClient.getUrl(Uri.parse(Urls.getReleasesGitHub));
|
|
HttpClientResponse response = await request.close();
|
|
String reply = await response.transform(utf8.decoder).join();
|
|
httpClient.close();
|
|
if (response.statusCode == 200) {
|
|
return {
|
|
'result': 'success',
|
|
'hasResponse': true,
|
|
'error': false,
|
|
'statusCode': response.statusCode,
|
|
'body': List<GitHubRelease>.from(jsonDecode(reply).map((entry) => GitHubRelease.fromJson(entry)))
|
|
};
|
|
}
|
|
else {
|
|
return {
|
|
'result': 'error',
|
|
'log': AppLog(
|
|
type: 'update_encryption_settings',
|
|
dateTime: DateTime.now(),
|
|
message: 'error_code_not_expected',
|
|
statusCode: response.statusCode.toString(),
|
|
resBody: reply,
|
|
)
|
|
};
|
|
}
|
|
} on SocketException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'SocketException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'SocketException'
|
|
)
|
|
};
|
|
} on TimeoutException {
|
|
return {
|
|
'result': 'no_connection',
|
|
'message': 'TimeoutException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'TimeoutException'
|
|
)
|
|
};
|
|
} on HandshakeException {
|
|
return {
|
|
'result': 'ssl_error',
|
|
'message': 'HandshakeException',
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: 'HandshakeException'
|
|
)
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
'result': 'error',
|
|
'message': e.toString(),
|
|
'log': AppLog(
|
|
type: 'check_latest_release_github',
|
|
dateTime: DateTime.now(),
|
|
message: e.toString()
|
|
)
|
|
};
|
|
}
|
|
} |