332 lines
9.9 KiB
Dart
332 lines
9.9 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
import 'package:easy_localization/easy_localization.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:gecko/globals.dart';
|
|
import 'package:gecko/models/queries_indexer.dart';
|
|
import 'package:gecko/providers/substrate_sdk.dart';
|
|
import 'package:graphql_flutter/graphql_flutter.dart';
|
|
|
|
class DuniterIndexer with ChangeNotifier {
|
|
Map<String, String?> walletNameIndexer = {};
|
|
String? fetchMoreCursor;
|
|
Map? pageInfo;
|
|
List? transBC;
|
|
List listIndexerEndpoints = [];
|
|
bool isLoadingIndexer = false;
|
|
|
|
void reload() {
|
|
notifyListeners();
|
|
}
|
|
|
|
Future<bool> checkIndexerEndpoint(String endpoint) async {
|
|
isLoadingIndexer = true;
|
|
notifyListeners();
|
|
final client = HttpClient();
|
|
client.connectionTimeout = const Duration(milliseconds: 4000);
|
|
try {
|
|
final request = await client.postUrl(Uri.parse('$endpoint/v1/graphql'));
|
|
final response = await request.close();
|
|
if (response.statusCode != 200) {
|
|
log.d('INDEXER IS OFFLINE');
|
|
indexerEndpoint = '';
|
|
isLoadingIndexer = false;
|
|
notifyListeners();
|
|
return false;
|
|
} else {
|
|
indexerEndpoint = endpoint;
|
|
await configBox.put('indexerEndpoint', endpoint);
|
|
// await configBox.put('customEndpoint', endpoint);
|
|
isLoadingIndexer = false;
|
|
notifyListeners();
|
|
final cache = HiveStore();
|
|
cache.reset();
|
|
return true;
|
|
}
|
|
} catch (e) {
|
|
log.d('INDEXER IS OFFLINE');
|
|
indexerEndpoint = '';
|
|
isLoadingIndexer = false;
|
|
notifyListeners();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Future checkIndexerEndpointBackground() async {
|
|
// final oldEndpoint = indexerEndpoint;
|
|
// while (true) {
|
|
// await Future.delayed(const Duration(seconds: 30));
|
|
// final isValid = await checkIndexerEndpoint(oldEndpoint);
|
|
// if (!isValid) {
|
|
// log.d('INDEXER IS OFFILINE');
|
|
// indexerEndpoint = '';
|
|
// } else {
|
|
// // log.d('Indexer is online');
|
|
// indexerEndpoint = oldEndpoint;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
Future<String> getValidIndexerEndpoint() async {
|
|
// await configBox.delete('indexerEndpoint');
|
|
|
|
listIndexerEndpoints = await rootBundle
|
|
.loadString('config/indexer_endpoints.json')
|
|
.then((jsonStr) => jsonDecode(jsonStr));
|
|
// _listEndpoints.shuffle();
|
|
|
|
log.d(listIndexerEndpoints);
|
|
listIndexerEndpoints.add('Personnalisé');
|
|
|
|
if (configBox.containsKey('customIndexer')) {
|
|
return configBox.get('customIndexer');
|
|
}
|
|
|
|
if (configBox.containsKey('indexerEndpoint') &&
|
|
listIndexerEndpoints.contains(configBox.get('indexerEndpoint'))) {
|
|
if (await checkIndexerEndpoint(configBox.get('indexerEndpoint'))) {
|
|
return configBox.get('indexerEndpoint');
|
|
}
|
|
}
|
|
|
|
int i = 0;
|
|
// String _endpoint = '';
|
|
int statusCode = 0;
|
|
|
|
final client = HttpClient();
|
|
client.connectionTimeout = const Duration(milliseconds: 3000);
|
|
|
|
do {
|
|
final listLenght = listIndexerEndpoints.length - 1;
|
|
if (i >= listLenght) {
|
|
log.e('NO VALID INDEXER ENDPOINT FOUND');
|
|
indexerEndpoint = '';
|
|
break;
|
|
}
|
|
log.d('${i + 1}n indexer endpoint try: ${listIndexerEndpoints[i]}');
|
|
|
|
if (i != 0) {
|
|
await Future.delayed(const Duration(milliseconds: 300));
|
|
}
|
|
|
|
try {
|
|
final endpointPath = '${listIndexerEndpoints[i]}/v1/graphql';
|
|
|
|
final request = await client.postUrl(Uri.parse(endpointPath));
|
|
final response = await request.close();
|
|
|
|
indexerEndpoint = listIndexerEndpoints[i];
|
|
await configBox.put('indexerEndpoint', listIndexerEndpoints[i]);
|
|
|
|
statusCode = response.statusCode;
|
|
i++;
|
|
} on TimeoutException catch (_) {
|
|
log.e('This endpoint is timeout, next');
|
|
statusCode = 50;
|
|
i++;
|
|
continue;
|
|
} on SocketException catch (_) {
|
|
log.e('This endpoint is a bad endpoint, next');
|
|
statusCode = 70;
|
|
i++;
|
|
continue;
|
|
} on Exception {
|
|
log.e('Unknown error');
|
|
statusCode = 60;
|
|
i++;
|
|
continue;
|
|
}
|
|
} while (statusCode != 200);
|
|
|
|
log.i('INDEXER: $indexerEndpoint');
|
|
return indexerEndpoint;
|
|
}
|
|
|
|
List parseHistory(blockchainTX, pubkey) {
|
|
List transBC = [];
|
|
int i = 0;
|
|
|
|
for (final trans in blockchainTX) {
|
|
final transaction = trans['node'];
|
|
final direction =
|
|
transaction['issuer_pubkey'] != pubkey ? 'RECEIVED' : 'SENT';
|
|
|
|
transBC.add(i);
|
|
transBC[i] = [];
|
|
transBC[i].add(DateTime.parse(transaction['created_at']));
|
|
final amountBrut = transaction['amount'];
|
|
final amount = removeDecimalZero(amountBrut / 100);
|
|
if (direction == "RECEIVED") {
|
|
transBC[i].add(transaction['issuer_pubkey']);
|
|
transBC[i].add(transaction['issuer']['identity']?['name'] ?? '');
|
|
} else if (direction == "SENT") {
|
|
transBC[i].add(transaction['receiver_pubkey']);
|
|
transBC[i].add(transaction['receiver']['identity']?['name'] ?? '');
|
|
}
|
|
transBC[i].add(amount);
|
|
transBC[i].add(direction);
|
|
|
|
i++;
|
|
}
|
|
return transBC;
|
|
}
|
|
|
|
FetchMoreOptions? mergeQueryResult(result, opts, pubkey, nRepositories) {
|
|
final List<dynamic>? blockchainTX =
|
|
(result.data['transaction_connection']['edges'] as List<dynamic>?);
|
|
|
|
pageInfo = result.data['transaction_connection']['pageInfo'];
|
|
fetchMoreCursor = pageInfo!['endCursor'];
|
|
final hasNextPage = pageInfo!['hasNextPage'];
|
|
final hasPreviousPage = pageInfo!['hasPreviousPage'];
|
|
log.d('endCursor: $fetchMoreCursor $hasNextPage $hasPreviousPage');
|
|
|
|
if (fetchMoreCursor != null) {
|
|
opts = FetchMoreOptions(
|
|
variables: {'cursor': fetchMoreCursor, 'number': nRepositories},
|
|
updateQuery: (previousResultData, fetchMoreResultData) {
|
|
final List<dynamic> repos = [
|
|
...previousResultData!['transaction_connection']['edges']
|
|
as List<dynamic>,
|
|
...fetchMoreResultData!['transaction_connection']['edges']
|
|
as List<dynamic>
|
|
];
|
|
|
|
fetchMoreResultData['transaction_connection']['edges'] = repos;
|
|
return fetchMoreResultData;
|
|
},
|
|
);
|
|
}
|
|
|
|
if (fetchMoreCursor != null) {
|
|
transBC = parseHistory(blockchainTX, pubkey);
|
|
} else {
|
|
log.i("###### DEBUG H - Début de l'historique");
|
|
}
|
|
|
|
return opts;
|
|
}
|
|
|
|
double removeDecimalZero(double n) {
|
|
String result = n.toStringAsFixed(n.truncateToDouble() == n ? 0 : 2);
|
|
return double.parse(result);
|
|
}
|
|
}
|
|
|
|
//// Manuals queries
|
|
|
|
Future<bool> isIdtyExist(String name) async {
|
|
final variables = <String, dynamic>{
|
|
'name': name,
|
|
};
|
|
final result = await _execQuery(isIdtyExistQ, variables);
|
|
return result.data!['identity']?.isEmpty ?? false ? false : true;
|
|
}
|
|
|
|
Future<DateTime> getBlockStart() async {
|
|
final result = await _execQuery(getBlockchainStartQ, {});
|
|
if (!result.hasException) {
|
|
startBlockchainTime =
|
|
DateTime.parse(result.data!['block'][0]['created_at']);
|
|
startBlockchainInitialized = true;
|
|
return startBlockchainTime;
|
|
}
|
|
return DateTime(0, 0, 0, 0, 0);
|
|
}
|
|
|
|
Future<QueryResult> _execQuery(
|
|
String query, Map<String, dynamic> variables) async {
|
|
final httpLink = HttpLink(
|
|
'$indexerEndpoint/v1/graphql',
|
|
);
|
|
|
|
final GraphQLClient client = GraphQLClient(
|
|
cache: GraphQLCache(),
|
|
link: httpLink,
|
|
);
|
|
|
|
final QueryOptions options =
|
|
QueryOptions(document: gql(query), variables: variables);
|
|
|
|
return await client.query(options);
|
|
}
|
|
|
|
Map computeHistoryView(repository, String address) {
|
|
final bool isUdUnit = configBox.get('isUdUnit') ?? false;
|
|
late double amount;
|
|
late String finalAmount;
|
|
final DateTime date = repository[0];
|
|
|
|
final dateForm = "${date.day} ${monthsInYear[date.month]!.substring(0, {
|
|
1,
|
|
2,
|
|
7,
|
|
9
|
|
}.contains(date.month) ? 4 : 3)}";
|
|
|
|
DateTime normalizeDate(DateTime inputDate) {
|
|
return DateTime(inputDate.year, inputDate.month, inputDate.day);
|
|
}
|
|
|
|
String getDateDelimiter() {
|
|
DateTime now = DateTime.now();
|
|
final transactionDate = normalizeDate(date.toLocal());
|
|
final todayDate = normalizeDate(now);
|
|
final yesterdayDate = normalizeDate(now.subtract(const Duration(days: 1)));
|
|
final isSameWeek = weekNumber(transactionDate) == weekNumber(now) &&
|
|
transactionDate.year == now.year;
|
|
final isTodayOrYesterday =
|
|
transactionDate == todayDate || transactionDate == yesterdayDate;
|
|
|
|
if (transactionDate == todayDate) {
|
|
return "today".tr();
|
|
} else if (transactionDate == yesterdayDate) {
|
|
return "yesterday".tr();
|
|
} else if (isSameWeek && !isTodayOrYesterday) {
|
|
return "thisWeek".tr();
|
|
} else if (!isSameWeek && !isTodayOrYesterday) {
|
|
if (transactionDate.year == now.year) {
|
|
return monthsInYear[transactionDate.month]!;
|
|
} else {
|
|
return "${monthsInYear[transactionDate.month]} ${transactionDate.year}";
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
final dateDelimiter = getDateDelimiter();
|
|
|
|
amount = repository[4] == 'RECEIVED' ? repository[3] : repository[3] * -1;
|
|
|
|
if (isUdUnit) {
|
|
amount = round(amount / balanceRatio);
|
|
finalAmount = 'ud'.tr(args: ['$amount ']);
|
|
} else {
|
|
finalAmount = '$amount $currencyName';
|
|
}
|
|
|
|
bool isMigrationTime =
|
|
startBlockchainInitialized && date.compareTo(startBlockchainTime) < 0;
|
|
|
|
//TODO: Migration date and transaction migration doesn't match, add this event to v2s indexer.
|
|
|
|
// log.d('debug date transaction: $date');
|
|
// log.d('debug date identity migration: ${sub.oldOwnerKeys[address]?[1]}');
|
|
// isChangeOwnerkeyTime = date.compareTo(sub.oldOwnerKeys[address]?[1] ?? DateTime(2000)) < 0;
|
|
|
|
return {
|
|
'finalAmount': finalAmount,
|
|
'isMigrationTime': isMigrationTime,
|
|
'dateDelimiter': dateDelimiter,
|
|
'dateForm': dateForm,
|
|
};
|
|
}
|
|
|
|
int weekNumber(DateTime date) {
|
|
int dayOfYear = int.parse(DateFormat("D").format(date));
|
|
return ((dayOfYear - date.weekday + 10) / 7).floor();
|
|
}
|