182 lines
6.2 KiB
Dart
182 lines
6.2 KiB
Dart
import 'dart:convert';
|
|
import 'dart:developer';
|
|
import 'package:contacts_plus/models/message.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:contacts_plus/models/authentication_data.dart';
|
|
import 'package:signalr_netcore/http_connection_options.dart';
|
|
import 'package:signalr_netcore/hub_connection.dart';
|
|
import 'package:signalr_netcore/hub_connection_builder.dart';
|
|
import 'package:signalr_netcore/ihub_protocol.dart';
|
|
import 'package:signalr_netcore/web_supporting_http_client.dart';
|
|
import 'package:uuid/uuid.dart';
|
|
import 'package:logging/logging.dart';
|
|
|
|
import 'config.dart';
|
|
|
|
class ApiClient {
|
|
static const String userIdKey = "userId";
|
|
static const String machineIdKey = "machineId";
|
|
static const String tokenKey = "token";
|
|
static const String passwordKey = "password";
|
|
|
|
ApiClient({required AuthenticationData authenticationData}) : _authenticationData = authenticationData {
|
|
if (_authenticationData.isAuthenticated) {
|
|
//hub.start();
|
|
}
|
|
}
|
|
|
|
late final NeosHub hub = NeosHub(token: authorizationHeader.values.first);
|
|
final AuthenticationData _authenticationData;
|
|
|
|
String get userId => _authenticationData.userId;
|
|
bool get isAuthenticated => _authenticationData.isAuthenticated;
|
|
|
|
static Future<AuthenticationData> tryLogin({
|
|
required String username,
|
|
required String password,
|
|
bool rememberMe=true,
|
|
bool rememberPass=false
|
|
}) async {
|
|
final body = {
|
|
"username": username,
|
|
"password": password,
|
|
"rememberMe": rememberMe,
|
|
"secretMachineId": const Uuid().v4(),
|
|
};
|
|
final response = await http.post(
|
|
buildFullUri("/UserSessions"),
|
|
headers: {"Content-Type": "application/json"},
|
|
body: jsonEncode(body));
|
|
if (response.statusCode == 400) {
|
|
throw "Invalid Credentials";
|
|
}
|
|
checkResponse(response);
|
|
|
|
final authData = AuthenticationData.fromMap(jsonDecode(response.body));
|
|
if (authData.isAuthenticated) {
|
|
const FlutterSecureStorage storage = FlutterSecureStorage();
|
|
await storage.write(key: userIdKey, value: authData.userId);
|
|
await storage.write(key: machineIdKey, value: authData.secretMachineId);
|
|
await storage.write(key: tokenKey, value: authData.token);
|
|
if (rememberPass) await storage.write(key: passwordKey, value: password);
|
|
}
|
|
return authData;
|
|
}
|
|
|
|
static Future<AuthenticationData> tryCachedLogin() async {
|
|
const FlutterSecureStorage storage = FlutterSecureStorage();
|
|
String? userId = await storage.read(key: userIdKey);
|
|
String? machineId = await storage.read(key: machineIdKey);
|
|
String? token = await storage.read(key: tokenKey);
|
|
String? password = await storage.read(key: passwordKey);
|
|
|
|
if (userId == null || machineId == null) {
|
|
return AuthenticationData.unauthenticated();
|
|
}
|
|
|
|
if (token != null) {
|
|
final response = await http.get(buildFullUri("/users/$userId"), headers: {
|
|
"Authorization": "neos $userId:$token"
|
|
});
|
|
if (response.statusCode == 200) {
|
|
return AuthenticationData(userId: userId, token: token, secretMachineId: machineId, isAuthenticated: true);
|
|
}
|
|
}
|
|
|
|
if (password != null) {
|
|
try {
|
|
userId = userId.startsWith("U-") ? userId.replaceRange(0, 2, "") : userId;
|
|
final loginResult = await tryLogin(username: userId, password: password, rememberPass: true);
|
|
if (loginResult.isAuthenticated) return loginResult;
|
|
} catch (_) {
|
|
// We don't need to notify the user if the cached login fails behind the scenes, so just ignore any exceptions.
|
|
}
|
|
}
|
|
return AuthenticationData.unauthenticated();
|
|
}
|
|
|
|
static void checkResponse(http.Response response) {
|
|
if (response.statusCode != 200) {
|
|
throw "Unknown Error${kDebugMode ? ": ${response.statusCode}|${response.body}" : ""}";
|
|
}
|
|
}
|
|
|
|
Map<String, String> get authorizationHeader => {
|
|
"Authorization": "neos ${_authenticationData.userId}:${_authenticationData.token}"
|
|
};
|
|
|
|
static Uri buildFullUri(String path) => Uri.parse("${Config.apiBaseUrl}/api$path");
|
|
|
|
Future<http.Response> get(String path, {Map<String, String>? headers}) {
|
|
headers ??= {};
|
|
headers.addAll(authorizationHeader);
|
|
return http.get(buildFullUri(path), headers: headers);
|
|
}
|
|
|
|
Future<http.Response> post(String path, {Object? body, Map<String, String>? headers}) {
|
|
headers ??= {};
|
|
headers["Content-Type"] = "application/json";
|
|
headers.addAll(authorizationHeader);
|
|
return http.post(buildFullUri(path), headers: headers, body: body);
|
|
}
|
|
|
|
Future<http.Response> put(String path, {Object? body, Map<String, String>? headers}) {
|
|
headers ??= {};
|
|
headers.addAll(authorizationHeader);
|
|
return http.put(buildFullUri(path), headers: headers, body: body);
|
|
}
|
|
|
|
Future<http.Response> delete(String path, {Map<String, String>? headers}) {
|
|
headers ??= {};
|
|
headers.addAll(authorizationHeader);
|
|
return http.delete(buildFullUri(path), headers: headers);
|
|
}
|
|
}
|
|
|
|
class NeosHub {
|
|
late final HubConnection hubConnection;
|
|
final Logger _logger = Logger("NeosHub");
|
|
|
|
NeosHub({required String token}) {
|
|
hubConnection = HubConnectionBuilder()
|
|
.withUrl(
|
|
Config.neosHubUrl,
|
|
options: HttpConnectionOptions(
|
|
headers: MessageHeaders()
|
|
..setHeaderValue("Authorization", token),
|
|
httpClient: WebSupportingHttpClient(
|
|
_logger,
|
|
),
|
|
logger: _logger,
|
|
logMessageContent: true
|
|
),
|
|
).withAutomaticReconnect().build();
|
|
hubConnection.onreconnecting(({error}) {
|
|
log("onreconnecting called with error $error");
|
|
});
|
|
hubConnection.onreconnected(({connectionId}) {
|
|
log("onreconnected called");
|
|
});
|
|
hubConnection.on("ReceiveMessage", _handleReceiveMessage);
|
|
}
|
|
|
|
void start() {
|
|
hubConnection.start()?.onError((error, stackTrace) => log(error.toString())).whenComplete(() {
|
|
log("Hub connection established");
|
|
});
|
|
}
|
|
|
|
Future<void> sendMessage(Message message) async {
|
|
await hubConnection.send("SendMessage", args: [message.toMap()]);
|
|
}
|
|
|
|
void _handleReceiveMessage(List<Object?>? params) {
|
|
log("Message received.");
|
|
if (params == null) return;
|
|
for(var obj in params) {
|
|
log("$obj");
|
|
}
|
|
}
|
|
}
|