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

767 lines
20 KiB
Dart
Raw Normal View History

2019-02-07 07:35:19 +01:00
import 'dart:convert';
import 'dart:async';
2021-01-17 15:08:32 +01:00
import 'package:ferry/ferry.dart';
import 'package:git_touch/utils/nil_store.dart';
// import 'package:in_app_review/in_app_review.dart';
import 'package:universal_io/io.dart';
2020-02-02 07:08:58 +01:00
import 'package:git_touch/models/bitbucket.dart';
2020-01-29 10:33:54 +01:00
import 'package:git_touch/models/gitea.dart';
2020-10-13 18:43:11 +02:00
import 'package:git_touch/models/gitee.dart';
import 'package:github/github.dart';
import 'package:gql_http_link/gql_http_link.dart';
import 'package:fimber/fimber.dart';
2019-02-07 07:35:19 +01:00
import 'package:http/http.dart' as http;
import 'package:uni_links/uni_links.dart';
import 'package:nanoid/nanoid.dart';
import 'package:url_launcher/url_launcher.dart';
import 'package:flutter/material.dart';
import 'package:flutter/cupertino.dart';
2019-02-07 07:35:19 +01:00
import 'package:shared_preferences/shared_preferences.dart';
2019-03-10 09:09:26 +01:00
import '../utils/utils.dart';
2019-09-08 14:07:35 +02:00
import 'account.dart';
2019-12-30 13:50:31 +01:00
import 'gitlab.dart';
2021-01-23 15:08:05 +01:00
import 'gogs.dart';
2020-01-27 06:24:01 +01:00
const clientId = 'df930d7d2e219f26142a';
2019-02-21 14:21:16 +01:00
class PlatformType {
static const github = 'github';
static const gitlab = 'gitlab';
2020-02-02 07:08:58 +01:00
static const bitbucket = 'bitbucket';
2020-01-29 10:33:54 +01:00
static const gitea = 'gitea';
2020-10-13 18:43:11 +02:00
static const gitee = 'gitee';
2021-01-23 15:08:05 +01:00
static const gogs = 'gogs';
}
2020-01-29 05:32:35 +01:00
class DataWithPage<T> {
T data;
int cursor;
bool hasMore;
int total;
2020-02-02 09:40:12 +01:00
DataWithPage({
@required this.data,
@required this.cursor,
@required this.hasMore,
this.total,
});
2020-01-29 05:32:35 +01:00
}
2020-02-02 10:30:48 +01:00
class BbPagePayload<T> {
T data;
String cursor;
bool hasMore;
int total;
BbPagePayload({
@required this.data,
@required this.cursor,
@required this.hasMore,
this.total,
});
}
2019-09-27 14:52:38 +02:00
class AuthModel with ChangeNotifier {
2019-09-26 16:14:14 +02:00
static const _apiPrefix = 'https://api.github.com';
2019-02-21 14:21:16 +01:00
// static final inAppReview = InAppReview.instance;
var hasRequestedReview = false;
2019-09-27 14:52:38 +02:00
List<Account> _accounts;
2019-09-26 16:14:14 +02:00
int activeAccountIndex;
2019-02-07 07:35:19 +01:00
StreamSubscription<Uri> _sub;
bool loading = false;
2019-02-07 07:35:19 +01:00
2019-09-27 14:52:38 +02:00
List<Account> get accounts => _accounts;
Account get activeAccount {
2019-09-26 16:14:14 +02:00
if (activeAccountIndex == null || _accounts == null) return null;
return _accounts[activeAccountIndex];
2019-02-07 07:35:19 +01:00
}
2019-01-30 07:46:18 +01:00
2019-09-26 16:14:14 +02:00
String get token => activeAccount.token;
2019-09-27 14:52:38 +02:00
_addAccount(Account account) async {
2020-02-01 11:14:42 +01:00
_accounts = [...accounts, account];
// Save
final prefs = await SharedPreferences.getInstance();
await prefs.setString(StorageKeys.accounts, json.encode(_accounts));
}
2020-02-01 11:30:32 +01:00
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();
}
2019-02-07 07:35:19 +01:00
// https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/#web-application-flow
Future<void> _onSchemeDetected(Uri uri) async {
await closeWebView();
2019-09-08 14:07:35 +02:00
loading = true;
notifyListeners();
2019-09-26 16:14:14 +02:00
// Get token by code
final res = await http.post(
2020-01-27 06:24:01 +01:00
'https://git-touch-oauth.now.sh/api/token',
2019-02-07 07:35:19 +01:00
headers: {
HttpHeaders.acceptHeader: 'application/json',
HttpHeaders.contentTypeHeader: 'application/json',
},
body: json.encode({
'client_id': clientId,
2019-09-26 16:14:14 +02:00
'code': uri.queryParameters['code'],
'state': _oauthState,
2019-02-07 07:35:19 +01:00
}),
);
2019-09-26 16:14:14 +02:00
final token = json.decode(res.body)['access_token'] as String;
2019-10-03 06:55:17 +02:00
await loginWithToken(token);
}
2019-02-07 07:35:19 +01:00
2019-10-03 06:55:17 +02:00
Future<void> loginWithToken(String token) async {
2020-02-01 10:00:30 +01:00
try {
final queryData = await query('''
2019-02-07 07:35:19 +01:00
{
viewer {
login
avatarUrl
}
}
''', token);
2019-02-07 07:35:19 +01:00
2020-02-01 10:00:30 +01:00
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();
}
2019-02-07 07:35:19 +01:00
}
2019-02-21 14:21:16 +01:00
Future<void> loginToGitlab(String domain, String token) async {
2020-02-06 07:38:43 +01:00
domain = domain.trim();
token = token.trim();
2020-02-01 10:00:30 +01:00
loading = true;
notifyListeners();
2019-02-21 14:21:16 +01:00
try {
2019-09-26 16:14:14 +02:00
final res = await http
2019-02-21 14:21:16 +01:00
.get('$domain/api/v4/user', headers: {'Private-Token': token});
2019-09-26 16:14:14 +02:00
final info = json.decode(res.body);
2019-02-21 14:21:16 +01:00
if (info['message'] != null) {
throw info['message'];
}
if (info['error'] != null) {
throw info['error'] +
'. ' +
(info['error_description'] != null
? info['error_description']
: '');
}
2019-12-30 13:50:31 +01:00
final user = GitlabUser.fromJson(info);
2019-09-27 14:52:38 +02:00
await _addAccount(Account(
2019-09-26 16:14:14 +02:00
platform: PlatformType.gitlab,
domain: domain,
token: token,
2019-12-30 13:50:31 +01:00
login: user.username,
avatarUrl: user.avatarUrl,
gitlabId: user.id,
));
2019-02-21 14:21:16 +01:00
} finally {
2019-09-08 14:07:35 +02:00
loading = false;
notifyListeners();
2019-02-21 14:21:16 +01:00
}
}
2019-12-11 16:37:29 +01:00
Future<String> fetchWithGitlabToken(String p) async {
final res = await http.get(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(
'${activeAccount.domain}/api/v4$p',
headers: {
'Private-Token': token,
HttpHeaders.contentTypeHeader: 'application/json'
},
body: jsonEncode(body),
);
} else {
res = await http.get('${activeAccount.domain}/api/v4$p',
headers: {'Private-Token': token});
}
2019-11-01 18:12:17 +01:00
final info = json.decode(utf8.decode(res.bodyBytes));
2020-01-30 05:53:07 +01:00
if (info is Map && info['message'] != null) throw info['message'];
2019-11-01 18:12:17 +01:00
return info;
}
2020-01-29 05:32:35 +01:00
Future<DataWithPage> fetchGitlabWithPage(String p) async {
final res = await http.get('${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));
2020-01-30 05:53:07 +01:00
if (info is Map && info['message'] != null) throw info['message'];
return DataWithPage(
data: info,
cursor: next,
hasMore: next != null,
total:
int.tryParse(res.headers['X-Total'] ?? res.headers['x-total'] ?? ''),
);
2020-01-29 05:32:35 +01:00
}
2020-01-29 10:33:54 +01:00
Future loginToGitea(String domain, String token) async {
2020-02-06 07:38:43 +01:00
domain = domain.trim();
token = token.trim();
2020-01-29 10:33:54 +01:00
try {
loading = true;
notifyListeners();
final res = await http.get('$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 {
http.Response res;
Map<String, String> headers = {
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
'${activeAccount.domain}/api/v1$p',
headers: headers,
);
break;
}
case 'POST':
{
res = await http.post(
'${activeAccount.domain}/api/v1$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
'${activeAccount.domain}/api/v1$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
default:
{
res = await http.get('${activeAccount.domain}/api/v1$p',
headers: headers);
break;
}
}
if (requestType != 'DELETE') {
final info = json.decode(utf8.decode(res.bodyBytes));
return info;
}
return;
2019-12-04 15:02:22 +01:00
}
Future<DataWithPage> fetchGiteaWithPage(String path,
{int page, int limit}) async {
2021-01-23 15:08:05 +01:00
page = page ?? 1;
limit = limit ?? pageSize;
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.length > 0,
total: int.tryParse(res.headers['x-total-count'] ?? ''),
);
}
Future loginToGogs(String domain, String token) async {
domain = domain.trim();
token = token.trim();
try {
loading = true;
notifyListeners();
final res = await http.get('$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 {
http.Response res;
Map<String, String> headers = {
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
'${activeAccount.domain}/api/v1$p',
headers: headers,
);
break;
}
case 'POST':
{
res = await http.post(
'${activeAccount.domain}/api/v1$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
'${activeAccount.domain}/api/v1$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
default:
{
res = await http.get('${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 ?? pageSize;
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'});
2020-02-01 08:21:42 +01:00
final info = json.decode(utf8.decode(res.bodyBytes));
2020-02-01 08:21:42 +01:00
return DataWithPage(
data: info,
cursor: page + 1,
hasMore: info is List && info.length > 0,
total: int.tryParse(res.headers['x-total-count'] ?? ''),
2020-02-01 08:21:42 +01:00
);
}
Future fetchGitee(
String p, {
requestType = 'GET',
Map<String, dynamic> body = const {},
}) async {
http.Response res;
Map<String, String> headers = {
'Authorization': 'token $token',
HttpHeaders.contentTypeHeader: 'application/json'
};
switch (requestType) {
case 'DELETE':
{
await http.delete(
'${activeAccount.domain}/api/v5$p',
headers: headers,
);
return;
}
case 'PUT':
{
await http.put(
'${activeAccount.domain}/api/v5$p',
headers: headers,
);
return;
}
case 'POST':
{
res = await http.post(
'${activeAccount.domain}/api/v5$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'PATCH':
{
res = await http.patch(
'${activeAccount.domain}/api/v5$p',
headers: headers,
body: jsonEncode(body),
);
break;
}
case 'NO CONTENT':
{
res = await http.get('${activeAccount.domain}/api/v5$p',
headers: headers);
return res;
}
default:
{
res = await http.get('${activeAccount.domain}/api/v5$p',
headers: headers);
break;
}
}
final info = json.decode(utf8.decode(res.bodyBytes));
return info;
2020-10-17 11:35:08 +02:00
}
2020-10-17 12:09:36 +02:00
Future<DataWithPage> fetchGiteeWithPage(String path,
{int page, int limit}) async {
page = page ?? 1;
limit = limit ?? pageSize;
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));
2020-10-17 14:46:47 +02:00
final totalPage = int.tryParse(res.headers['total_page'] ?? '');
final totalCount = int.tryParse(res.headers['total_count'] ?? '');
2020-10-17 12:09:36 +02:00
return DataWithPage(
data: info,
cursor: page + 1,
2020-10-17 14:46:47 +02:00
hasMore: totalPage == null ? info.length > limit : totalPage > page,
total: totalCount,
2020-10-17 12:09:36 +02:00
);
}
2020-02-02 07:08:58 +01:00
Future loginToBb(String domain, String username, String appPassword) async {
2020-02-06 07:38:43 +01:00
domain = domain.trim();
username = username.trim();
appPassword = appPassword.trim();
2020-02-02 07:08:58 +01:00
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,
2020-02-02 07:24:22 +01:00
avatarUrl: user.avatarUrl,
2020-02-02 07:08:58 +01:00
appPassword: appPassword,
accountId: user.accountId,
2020-02-02 07:08:58 +01:00
));
} finally {
loading = false;
notifyListeners();
}
}
Future<http.Response> fetchBb(
String p, {
isPost = false,
Map<String, dynamic> body = const {},
}) async {
2020-02-02 10:30:48 +01:00
if (p.startsWith('/') && !p.startsWith('/api')) p = '/api/2.0$p';
2020-02-02 09:40:12 +01:00
final input = Uri.parse(p);
final uri = Uri.parse(activeAccount.domain).replace(
userInfo: '${activeAccount.login}:${activeAccount.appPassword}',
path: input.path,
query: input.query,
);
if (isPost) {
return http.post(
uri,
headers: {HttpHeaders.contentTypeHeader: 'application/json'},
body: jsonEncode(body),
);
}
2020-02-02 12:50:00 +01:00
return http.get(uri);
2020-02-02 09:40:12 +01:00
}
Future fetchBbJson(
String p, {
isPost = false,
Map<String, dynamic> body = const {},
}) async {
final res = await fetchBb(
p,
isPost: isPost,
body: body,
);
2020-02-02 12:50:00 +01:00
return json.decode(utf8.decode(res.bodyBytes));
}
Future<BbPagePayload<List>> fetchBbWithPage(String p) async {
final data = await fetchBbJson(p);
final v = BbPagination.fromJson(data);
2020-02-02 10:30:48 +01:00
return BbPagePayload(
cursor: v.next,
2020-02-02 09:40:12 +01:00
total: v.size,
data: v.values,
hasMore: v.next != null,
);
}
2020-10-13 18:43:11 +02:00
Future loginToGitee(String token) async {
token = token.trim();
try {
loading = true;
notifyListeners();
final res = await http.get('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(
2020-10-17 11:27:13 +02:00
platform: PlatformType.gitee,
2020-10-13 18:43:11 +02:00
domain: 'https://gitee.com',
token: token,
login: user.login,
avatarUrl: user.avatarUrl,
));
} finally {
loading = false;
notifyListeners();
}
}
2019-11-05 08:09:54 +01:00
Future<void> init() async {
2019-09-26 16:14:14 +02:00
// Listen scheme
2019-09-08 14:07:35 +02:00
_sub = getUriLinksStream().listen(_onSchemeDetected, onError: (err) {
Fimber.e('getUriLinksStream failed', ex: err);
2019-09-08 14:07:35 +02:00
});
var prefs = await SharedPreferences.getInstance();
2019-02-07 07:35:19 +01:00
2019-09-26 16:14:14 +02:00
// Read accounts
2019-02-21 14:21:16 +01:00
try {
2019-09-26 16:14:14 +02:00
String str = prefs.getString(StorageKeys.accounts);
2020-02-08 08:00:44 +01:00
// Fimber.d('read accounts: $str');
2019-09-26 16:14:14 +02:00
_accounts = (json.decode(str ?? '[]') as List)
2019-09-27 14:52:38 +02:00
.map((item) => Account.fromJson(item))
2019-09-26 16:14:14 +02:00
.toList();
activeAccountIndex = prefs.getInt(StorageKeys.defaultAccount);
if (activeAccount != null)
_activeTab = prefs.getInt(
StorageKeys.getDefaultStartTabKey(activeAccount.platform)) ??
0;
2019-02-21 14:21:16 +01:00
} catch (err) {
Fimber.e('prefs getAccount failed', ex: err);
2019-09-26 16:14:14 +02:00
_accounts = [];
2019-02-21 14:21:16 +01:00
}
2019-09-08 14:07:35 +02:00
notifyListeners();
2019-02-07 07:35:19 +01:00
}
2019-10-03 06:24:09 +02:00
@override
void dispose() {
_sub.cancel();
super.dispose();
}
Future<void> setDefaultAccount(int v) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setInt(StorageKeys.defaultAccount, v);
Fimber.d('write default account: $v');
notifyListeners();
}
2020-02-01 07:44:15 +01:00
var rootKey = UniqueKey();
2020-05-01 12:05:49 +02:00
setActiveAccountAndReload(int index) async {
2020-02-01 07:44:15 +01:00
// https://stackoverflow.com/a/50116077
rootKey = UniqueKey();
2019-09-26 16:14:14 +02:00
activeAccountIndex = index;
setDefaultAccount(activeAccountIndex);
2020-05-01 12:05:49 +02:00
final prefs = await SharedPreferences.getInstance();
_activeTab = prefs.getInt(
StorageKeys.getDefaultStartTabKey(activeAccount.platform)) ??
0;
_ghClient = null;
2020-01-14 07:46:36 +01:00
_gqlClient = null;
2019-09-08 14:07:35 +02:00
notifyListeners();
2020-12-13 06:08:17 +01:00
// TODO: strategy
// waiting for 1min to request review
2020-12-13 06:08:17 +01:00
// if (!hasRequestedReview) {
// hasRequestedReview = true;
// Timer(Duration(minutes: 1), () async {
// if (await inAppReview.isAvailable()) {
// inAppReview.requestReview();
// }
// });
// }
2019-02-07 07:35:19 +01:00
}
// http timeout
var _timeoutDuration = Duration(seconds: 10);
// var _timeoutDuration = Duration(seconds: 1);
GitHub _ghClient;
GitHub get ghClient {
if (token == null) return null;
if (_ghClient == null) {
_ghClient = GitHub(auth: Authentication.withToken(token));
}
return _ghClient;
}
2021-01-17 15:08:32 +01:00
Client _gqlClient;
Client get gqlClient {
if (token == null) return null;
2019-11-06 14:27:37 +01:00
if (_gqlClient == null) {
2021-01-17 15:08:32 +01:00
_gqlClient = Client(
link: HttpLink(
2019-12-07 06:18:44 +01:00
_apiPrefix + '/graphql',
defaultHeaders: {HttpHeaders.authorizationHeader: 'token $token'},
),
2021-01-17 15:08:32 +01:00
cache: Cache(store: NilStore()),
);
}
2019-11-06 14:27:37 +01:00
return _gqlClient;
}
2019-11-06 14:27:37 +01:00
2019-02-07 07:35:19 +01:00
Future<dynamic> query(String query, [String _token]) async {
if (_token == null) {
_token = token;
}
if (_token == null) {
2019-09-26 16:14:14 +02:00
throw 'token is null';
2019-02-07 07:35:19 +01:00
}
final res = await http
2019-09-08 14:07:35 +02:00
.post(_apiPrefix + '/graphql',
headers: {
HttpHeaders.authorizationHeader: 'token $_token',
HttpHeaders.contentTypeHeader: 'application/json'
},
body: json.encode({'query': query}))
.timeout(_timeoutDuration);
// Fimber.d(res.body);
2019-02-07 07:35:19 +01:00
final data = json.decode(res.body);
if (data['errors'] != null) {
2019-09-26 16:14:14 +02:00
throw data['errors'][0]['message'];
2019-02-07 07:35:19 +01:00
}
2019-02-10 12:15:50 +01:00
2019-02-07 07:35:19 +01:00
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(','));
2019-09-29 07:32:53 +02:00
launchUrl(
2019-09-21 19:02:14 +02:00
'https://github.com/login/oauth/authorize?client_id=$clientId&redirect_uri=gittouch://login&scope=$scope&state=$_oauthState',
);
}
2020-05-01 12:05:49 +02:00
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();
}
2019-01-30 07:46:18 +01:00
}