git-touch-android-ios-app/lib/models/auth.dart

753 lines
20 KiB
Dart

import 'dart:async';
import 'dart:convert';
import 'package:ferry/ferry.dart';
import 'package:fimber/fimber.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/widgets.dart';
import 'package:git_touch/models/account.dart';
import 'package:git_touch/models/bitbucket.dart';
import 'package:git_touch/models/gitea.dart';
import 'package:git_touch/models/gitee.dart';
import 'package:git_touch/models/gitlab.dart';
import 'package:git_touch/models/gogs.dart';
import 'package:git_touch/utils/utils.dart';
import 'package:github/github.dart';
import 'package:gql_http_link/gql_http_link.dart';
import 'package:http/http.dart' as http;
import 'package:nanoid/nanoid.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:uni_links/uni_links.dart';
// import 'package:in_app_review/in_app_review.dart';
import 'package:universal_io/io.dart';
import 'package:url_launcher/url_launcher.dart';
const clientId = 'df930d7d2e219f26142a';
class PlatformType {
static const github = 'github';
static const gitlab = 'gitlab';
static const bitbucket = 'bitbucket';
static const gitea = 'gitea';
static const gitee = 'gitee';
static const gogs = 'gogs';
}
class DataWithPage<T> {
DataWithPage({
required this.data,
required this.cursor,
required this.hasMore,
required this.total,
});
T data;
int cursor;
bool hasMore;
int total;
}
class AuthModel with ChangeNotifier {
static const _apiPrefix = 'https://api.github.com';
// static final inAppReview = InAppReview.instance;
var hasRequestedReview = false;
List<Account> _accounts = [];
int? activeAccountIndex;
late StreamSubscription<Uri?> _sub;
bool loading = false;
List<Account>? get accounts => _accounts;
Account? get activeAccount {
if (activeAccountIndex == null || _accounts.isEmpty) return null;
return _accounts[activeAccountIndex!];
}
String get token => activeAccount!.token;
_addAccount(Account account) async {
_accounts = [...accounts!, account];
// Save
final prefs = await SharedPreferences.getInstance();
await prefs.setString(StorageKeys.accounts, json.encode(_accounts));
}
removeAccount(int index) async {
if (activeAccountIndex == index) {
activeAccountIndex = null;
}
_accounts.removeAt(index);
// Save
final prefs = await SharedPreferences.getInstance();
await prefs.setString(StorageKeys.accounts, json.encode(_accounts));
notifyListeners();
}
// https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#web-application-flow
Future<void> _onSchemeDetected(Uri? uri) async {
await closeInAppWebView();
loading = true;
notifyListeners();
// Get token by code
final res = await http.post(
Uri.parse('https://git-touch-oauth.vercel.app/api/token'),
headers: {
HttpHeaders.acceptHeader: 'application/json',
HttpHeaders.contentTypeHeader: 'application/json',
},
body: json.encode({
'client_id': clientId,
'code': uri!.queryParameters['code'],
'state': _oauthState,
}),
);
final token = json.decode(res.body)['access_token'] as String;
await loginWithToken(token);
}
Future<void> loginWithToken(String token) async {
try {
final queryData = await query('''
{
viewer {
login
avatarUrl
}
}
''', token);
await _addAccount(Account(
platform: PlatformType.github,
domain: 'https://github.com',
token: token,
login: queryData['viewer']['login'] as String,
avatarUrl: queryData['viewer']['avatarUrl'] as String,
));
} finally {
loading = false;
notifyListeners();
}
}
Future<void> loginToGitlab(String domain, String token) async {
domain = domain.trim();
token = token.trim();
loading = true;
notifyListeners();
try {
final res = await http.get(Uri.parse('$domain/api/v4/user'),
headers: {'Private-Token': token});
final info = json.decode(res.body);
if (info['message'] != null) {
throw info['message'];
}
if (info['error'] != null) {
throw info['error'] + '. ' + (info['error_description'] ?? '');
}
final user = GitlabUser.fromJson(info);
await _addAccount(Account(
platform: PlatformType.gitlab,
domain: domain,
token: token,
login: user.username!,
avatarUrl: user.avatarUrl!,
gitlabId: user.id,
));
} finally {
loading = false;
notifyListeners();
}
}
Future<String> fetchWithGitlabToken(String p) async {
final res = await http.get(Uri.parse(p), headers: {'Private-Token': token});
return res.body;
}
Future fetchGitlab(String p,
{isPost = false, Map<String, dynamic> body = const {}}) async {
http.Response res;
if (isPost) {
res = await http.post(
Uri.parse('${activeAccount!.domain}/api/v4$p'),
headers: {
'Private-Token': token,
HttpHeaders.contentTypeHeader: 'application/json'
},
body: jsonEncode(body),
);
} else {
res = await http.get(Uri.parse('${activeAccount!.domain}/api/v4$p'),
headers: {'Private-Token': token});
}
final info = json.decode(utf8.decode(res.bodyBytes));
if (info is Map && info['message'] != null) throw info['message'];
return info;
}
Future<DataWithPage> fetchGitlabWithPage(String p) async {
final res = await http.get(Uri.parse('${activeAccount!.domain}/api/v4$p'),
headers: {'Private-Token': token});
final next = int.tryParse(
res.headers['X-Next-Pages'] ?? res.headers['x-next-page'] ?? '');
final info = json.decode(utf8.decode(res.bodyBytes));
if (info is Map && info['message'] != null) throw info['message'];
return DataWithPage(
data: info,
cursor: next ?? 1,
hasMore: next != null,
total: int.tryParse(
res.headers['X-Total'] ?? res.headers['x-total'] ?? '') ??
TOTAL_COUNT_FALLBACK,
);
}
Future loginToGitea(String domain, String token) async {
domain = domain.trim();
token = token.trim();
try {
loading = true;
notifyListeners();
final res = await http.get(Uri.parse('$domain/api/v1/user'),
headers: {'Authorization': 'token $token'});
final info = json.decode(res.body);
if (info['message'] != null) {
throw info['message'];
}
final user = GiteaUser.fromJson(info);
await _addAccount(Account(
platform: PlatformType.gitea,
domain: domain,
token: token,
login: user.login!,
avatarUrl: user.avatarUrl!,
));
} finally {
loading = false;
notifyListeners();
}
}
Future fetchGitea(
String p, {
requestType = 'GET',
Map<String, dynamic> body = const {},
}) async {
late http.Response res;
final headers = <String, String>{
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
);
break;
}
case 'POST':
{
res = await http.post(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
default:
{
res = await http.get(Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers);
break;
}
}
if (requestType != 'DELETE') {
final info = json.decode(utf8.decode(res.bodyBytes));
return info;
}
return;
}
Future<DataWithPage> fetchGiteaWithPage(String path,
{int? page, int? limit}) async {
page = page ?? 1;
limit = limit ?? PAGE_SIZE;
var uri = Uri.parse('${activeAccount!.domain}/api/v1$path');
uri = uri.replace(
queryParameters: {
'page': page.toString(),
'limit': limit.toString(),
...uri.queryParameters,
},
);
final res = await http.get(uri, headers: {'Authorization': 'token $token'});
final info = json.decode(utf8.decode(res.bodyBytes));
return DataWithPage(
data: info,
cursor: page + 1,
hasMore: info is List && info.isNotEmpty,
total: int.tryParse(res.headers['x-total-count'] ?? '') ??
TOTAL_COUNT_FALLBACK,
);
}
Future loginToGogs(String domain, String token) async {
domain = domain.trim();
token = token.trim();
try {
loading = true;
notifyListeners();
final res = await http.get(Uri.parse('$domain/api/v1/user'),
headers: {'Authorization': 'token $token'});
final info = json.decode(res.body);
if (info['message'] != null) {
throw info['message'];
}
final user = GogsUser.fromJson(info);
await _addAccount(Account(
platform: PlatformType.gogs,
domain: domain,
token: token,
login: user.username!,
avatarUrl: user.avatarUrl!,
));
} finally {
loading = false;
notifyListeners();
}
}
// TODO: refactor
Future fetchGogs(
String p, {
requestType = 'GET',
Map<String, dynamic> body = const {},
}) async {
late http.Response res;
final headers = <String, String>{
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
);
break;
}
case 'POST':
{
res = await http.post(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
default:
{
res = await http.get(Uri.parse('${activeAccount!.domain}/api/v1$p'),
headers: headers);
break;
}
}
if (requestType != 'DELETE') {
final info = json.decode(utf8.decode(res.bodyBytes));
return info;
}
return;
}
Future<DataWithPage> fetchGogsWithPage(String path,
{int? page, int? limit}) async {
page = page ?? 1;
limit = limit ?? PAGE_SIZE;
var uri = Uri.parse('${activeAccount!.domain}/api/v1$path');
uri = uri.replace(
queryParameters: {
'page': page.toString(),
'limit': limit.toString(),
...uri.queryParameters,
},
);
final res = await http.get(uri, headers: {'Authorization': 'token $token'});
final info = json.decode(utf8.decode(res.bodyBytes));
return DataWithPage(
data: info,
cursor: page + 1,
hasMore: info is List && info.isNotEmpty,
total: int.tryParse(res.headers['x-total-count'] ?? '') ??
TOTAL_COUNT_FALLBACK,
);
}
Future fetchGitee(
String p, {
requestType = 'GET',
Map<String, dynamic> body = const {},
}) async {
http.Response res;
final headers = <String, String>{
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers,
);
return;
}
case 'PUT':
{
await http.put(
Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers,
);
return;
}
case 'POST':
{
res = await http.post(
Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'NO CONTENT':
{
res = await http.get(Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers);
return res;
}
default:
{
res = await http.get(Uri.parse('${activeAccount!.domain}/api/v5$p'),
headers: headers);
break;
}
}
final info = json.decode(utf8.decode(res.bodyBytes));
return info;
}
Future<DataWithPage> fetchGiteeWithPage(String path,
{int? page, int? limit}) async {
page = page ?? 1;
limit = limit ?? PAGE_SIZE;
var uri = Uri.parse('${activeAccount!.domain}/api/v5$path');
uri = uri.replace(
queryParameters: {
'page': page.toString(),
'per_page': limit.toString(),
...uri.queryParameters,
},
);
final res = await http.get(uri, headers: {'Authorization': 'token $token'});
final info = json.decode(utf8.decode(res.bodyBytes));
final totalPage = int.tryParse(res.headers['total_page'] ?? '');
final totalCount =
int.tryParse(res.headers['total_count'] ?? '') ?? TOTAL_COUNT_FALLBACK;
return DataWithPage(
data: info,
cursor: page + 1,
hasMore: totalPage == null ? info.length > limit : totalPage > page,
total: totalCount,
);
}
Future loginToBb(String domain, String username, String appPassword) async {
domain = domain.trim();
username = username.trim();
appPassword = appPassword.trim();
try {
loading = true;
notifyListeners();
final uri = Uri.parse('$domain/api/2.0/user')
.replace(userInfo: '$username:$appPassword');
final res = await http.get(uri);
if (res.statusCode >= 400) {
throw 'status ${res.statusCode}';
}
final info = json.decode(res.body);
final user = BbUser.fromJson(info);
await _addAccount(Account(
platform: PlatformType.bitbucket,
domain: domain,
token: user.username!,
login: username,
avatarUrl: user.avatarUrl!,
appPassword: appPassword,
accountId: user.accountId,
));
} finally {
loading = false;
notifyListeners();
}
}
Future<http.Response> fetchBb(
String p, {
isPost = false,
Map<String, dynamic> body = const {},
}) async {
if (p.startsWith('/') && !p.startsWith('/api')) p = '/api/2.0$p';
final input = Uri.parse(p);
final uri = Uri.parse(activeAccount!.domain).replace(
userInfo: '${activeAccount!.login}:${activeAccount!.appPassword}',
path: input.path,
queryParameters: {
'pagelen': PAGE_SIZE.toString(),
...input.queryParameters
},
);
if (isPost) {
return http.post(
uri,
headers: {HttpHeaders.contentTypeHeader: 'application/json'},
body: jsonEncode(body),
);
}
return http.get(uri);
}
Future fetchBbJson(
String p, {
isPost = false,
Map<String, dynamic> body = const {},
}) async {
final res = await fetchBb(
p,
isPost: isPost,
body: body,
);
return json.decode(utf8.decode(res.bodyBytes));
}
Future<ListPayload<dynamic, String?>> fetchBbWithPage(String p) async {
final data = await fetchBbJson(p);
final v = BbPagination.fromJson(data);
return ListPayload(
cursor: v.next,
items: v.values,
hasMore: v.next != null,
);
}
Future loginToGitee(String token) async {
token = token.trim();
try {
loading = true;
notifyListeners();
final res = await http.get(Uri.parse('https://gitee.com/api/v5/user'),
headers: {'Authorization': 'token $token'});
final info = json.decode(res.body);
if (info['message'] != null) {
throw info['message'];
}
final user = GiteeUser.fromJson(info);
await _addAccount(Account(
platform: PlatformType.gitee,
domain: 'https://gitee.com',
token: token,
login: user.login!,
avatarUrl: user.avatarUrl!,
));
} finally {
loading = false;
notifyListeners();
}
}
Future<void> init() async {
// Listen scheme
_sub = uriLinkStream.listen(_onSchemeDetected, onError: (err) {
Fimber.e('getUriLinksStream failed', ex: err);
});
final prefs = await SharedPreferences.getInstance();
// Read accounts
try {
final str = prefs.getString(StorageKeys.accounts);
// Fimber.d('read accounts: $str');
_accounts = (json.decode(str ?? '[]') as List)
.map((item) => Account.fromJson(item))
.toList();
activeAccountIndex = prefs.getInt(StorageKeys.iDefaultAccount);
if (activeAccount != null) {
_activeTab = prefs.getInt(
StorageKeys.getDefaultStartTabKey(activeAccount!.platform)) ??
0;
}
} catch (err) {
Fimber.e('prefs getAccount failed', ex: err);
_accounts = [];
}
notifyListeners();
}
@override
void dispose() {
_sub.cancel();
super.dispose();
}
Future<void> setDefaultAccount(int v) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setInt(StorageKeys.iDefaultAccount, v);
Fimber.d('write default account: $v');
notifyListeners();
}
var rootKey = UniqueKey();
reloadApp() {
rootKey = UniqueKey();
notifyListeners();
}
setActiveAccountAndReload(int index) async {
// https://stackoverflow.com/a/50116077
rootKey = UniqueKey();
activeAccountIndex = index;
setDefaultAccount(activeAccountIndex!);
final prefs = await SharedPreferences.getInstance();
_activeTab = prefs.getInt(
StorageKeys.getDefaultStartTabKey(activeAccount!.platform)) ??
0;
_ghClient = null;
_gqlClient = null;
notifyListeners();
// TODO: strategy
// waiting for 1min to request review
// if (!hasRequestedReview) {
// hasRequestedReview = true;
// Timer(Duration(minutes: 1), () async {
// if (await inAppReview.isAvailable()) {
// inAppReview.requestReview();
// }
// });
// }
}
// http timeout
final _timeoutDuration = const Duration(seconds: 10);
// var _timeoutDuration = Duration(seconds: 1);
GitHub? _ghClient;
GitHub get ghClient {
_ghClient ??= GitHub(auth: Authentication.withToken(token));
return _ghClient!;
}
Client? _gqlClient;
Client get gqlClient {
_gqlClient ??= Client(
link: HttpLink(
'$_apiPrefix/graphql',
defaultHeaders: {HttpHeaders.authorizationHeader: 'token $token'},
),
// https://ferrygraphql.com/docs/fetch-policies#default-fetchpolicies
defaultFetchPolicies: {
OperationType.query: FetchPolicy.NetworkOnly,
},
);
return _gqlClient!;
}
Future<dynamic> query(String query, [String? token]) async {
token ??= token;
final res = await http
.post(Uri.parse('$_apiPrefix/graphql'),
headers: {
HttpHeaders.authorizationHeader: 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
},
body: json.encode({'query': query}))
.timeout(_timeoutDuration);
// Fimber.d(res.body);
final data = json.decode(res.body);
if (data['errors'] != null) {
throw data['errors'][0]['message'];
}
return data['data'];
}
String? _oauthState;
void redirectToGithubOauth([publicOnly = false]) {
_oauthState = nanoid();
final repoScope = publicOnly ? 'public_repo' : 'repo';
final scope = Uri.encodeComponent(
['user', repoScope, 'read:org', 'notifications'].join(','));
launchStringUrl(
'https://github.com/login/oauth/authorize?client_id=$clientId&redirect_uri=gittouch://login&scope=$scope&state=$_oauthState',
);
}
int _activeTab = 0;
int get activeTab => _activeTab;
Future<void> setActiveTab(int v) async {
_activeTab = v;
final prefs = await SharedPreferences.getInstance();
await prefs.setInt(
StorageKeys.getDefaultStartTabKey(activeAccount!.platform), v);
Fimber.d('write default start tab for ${activeAccount!.platform}: $v');
notifyListeners();
}
}