stack_wallet/lib/services/notifications_service.dart

317 lines
10 KiB
Dart

import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:stackwallet/electrumx_rpc/electrumx.dart';
import 'package:stackwallet/hive/db.dart';
import 'package:stackwallet/models/exchange/change_now/exchange_transaction_status.dart';
import 'package:stackwallet/models/notification_model.dart';
import 'package:stackwallet/services/change_now/change_now.dart';
import 'package:stackwallet/services/node_service.dart';
import 'package:stackwallet/services/notifications_api.dart';
import 'package:stackwallet/services/trade_service.dart';
import 'package:stackwallet/utilities/enums/coin_enum.dart';
import 'package:stackwallet/utilities/logger.dart';
import 'package:stackwallet/utilities/prefs.dart';
class NotificationsService extends ChangeNotifier {
late NodeService nodeService;
late TradesService tradesService;
late Prefs prefs;
late ChangeNow changeNow;
NotificationsService._();
static final NotificationsService _instance = NotificationsService._();
static NotificationsService get instance => _instance;
Future<void> init({
required NodeService nodeService,
required TradesService tradesService,
required Prefs prefs,
required ChangeNow changeNow,
}) async {
this.nodeService = nodeService;
this.tradesService = tradesService;
this.prefs = prefs;
this.changeNow = changeNow;
}
// watched transactions
List<NotificationModel> get _watchedTransactionNotifications {
return DB.instance
.values<NotificationModel>(boxName: DB.boxNameWatchedTransactions);
}
Future<void> _addWatchedTxNotification(NotificationModel notification) async {
await DB.instance.put<NotificationModel>(
boxName: DB.boxNameWatchedTransactions,
key: notification.id,
value: notification);
}
Future<void> _deleteWatchedTxNotification(
NotificationModel notification) async {
await DB.instance.delete<NotificationModel>(
boxName: DB.boxNameWatchedTransactions, key: notification.id);
}
// watched trades
List<NotificationModel> get _watchedChangeNowTradeNotifications {
return DB.instance
.values<NotificationModel>(boxName: DB.boxNameWatchedTrades);
}
Future<void> _addWatchedTradeNotification(
NotificationModel notification) async {
await DB.instance.put<NotificationModel>(
boxName: DB.boxNameWatchedTrades,
key: notification.id,
value: notification);
}
Future<void> _deleteWatchedTradeNotification(
NotificationModel notification) async {
await DB.instance.delete<NotificationModel>(
boxName: DB.boxNameWatchedTrades, key: notification.id);
}
static Timer? _timer;
// todo: change this number?
static Duration notificationRefreshInterval = const Duration(seconds: 60);
void startCheckingWatchedNotifications() {
stopCheckingWatchedTransactions();
_timer = Timer.periodic(notificationRefreshInterval, (_) {
Logging.instance
.log("Periodic notifications update check", level: LogLevel.Info);
_checkTrades();
_checkTransactions();
});
}
void stopCheckingWatchedTransactions() {
_timer?.cancel();
_timer = null;
}
@override
void dispose() {
stopCheckingWatchedTransactions();
super.dispose();
}
void _checkTransactions() async {
for (final notification in _watchedTransactionNotifications) {
final Coin coin = coinFromPrettyName(notification.coinName);
final txid = notification.txid!;
final node = nodeService.getPrimaryNodeFor(coin: coin);
if (node != null) {
if (coin.isElectrumXCoin) {
final eNode = ElectrumXNode(
address: node.host,
port: node.port,
name: node.name,
id: node.id,
useSSL: node.useSSL,
);
final failovers = nodeService
.failoverNodesFor(coin: coin)
.map((e) => ElectrumXNode(
address: e.host,
port: e.port,
name: e.name,
id: e.id,
useSSL: e.useSSL,
))
.toList();
final client = ElectrumX.from(
node: eNode,
failovers: failovers,
prefs: prefs,
);
final tx = await client.getTransaction(txHash: txid);
int confirmations = tx["confirmations"] as int? ?? 0;
bool shouldWatchForUpdates = true;
// check if the number of confirmations is greater than the number
// required by the wallet to count the tx as confirmed and update the
// flag on whether this notification should still be monitored
if (confirmations >= coin.requiredConfirmations) {
shouldWatchForUpdates = false;
confirmations = coin.requiredConfirmations;
}
// grab confirms string to compare
final String newConfirms =
"($confirmations/${coin.requiredConfirmations})";
final String oldConfirms =
notification.title.substring(notification.title.lastIndexOf("("));
// only update if they don't match
if (oldConfirms != newConfirms) {
final String newTitle =
notification.title.replaceFirst(oldConfirms, newConfirms);
final updatedNotification = notification.copyWith(
title: newTitle,
shouldWatchForUpdates: shouldWatchForUpdates,
);
// remove from watch list if shouldWatchForUpdates was changed
if (!shouldWatchForUpdates) {
await _deleteWatchedTxNotification(notification);
}
// replaces the current notification with the updated one
add(updatedNotification, true);
}
} else {
// TODO: check non electrumx coins
}
}
}
}
void _checkTrades() async {
for (final notification in _watchedChangeNowTradeNotifications) {
final id = notification.changeNowId!;
final result = await changeNow.getTransactionStatus(id: id);
ChangeNowTransactionStatus? status = result.value?.status;
// only update if status has changed
if (status != null && status.name != notification.title) {
bool shouldWatchForUpdates = true;
// TODO: make sure we set shouldWatchForUpdates to correct value here
switch (status) {
case ChangeNowTransactionStatus.New:
case ChangeNowTransactionStatus.Waiting:
case ChangeNowTransactionStatus.Confirming:
case ChangeNowTransactionStatus.Exchanging:
case ChangeNowTransactionStatus.Verifying:
case ChangeNowTransactionStatus.Sending:
shouldWatchForUpdates = true;
break;
case ChangeNowTransactionStatus.Finished:
case ChangeNowTransactionStatus.Failed:
case ChangeNowTransactionStatus.Refunded:
shouldWatchForUpdates = false;
break;
}
final updatedNotification = notification.copyWith(
title: status.name,
shouldWatchForUpdates: shouldWatchForUpdates,
);
// remove from watch list if shouldWatchForUpdates was changed
if (!shouldWatchForUpdates) {
await _deleteWatchedTradeNotification(notification);
}
// replaces the current notification with the updated one
add(updatedNotification, true);
// update the trade in db
if (result.value != null) {
// fetch matching trade from db
final trade = tradesService.trades
.firstWhere((element) => element.id == result.value!.id);
// update status
final updatedTrade = trade.copyWith(
statusObject: result.value!,
statusString: result.value!.status.name,
);
// over write trade stored in db with updated version
tradesService.add(trade: updatedTrade, shouldNotifyListeners: true);
}
}
}
}
bool get hasUnreadNotifications {
// final count = (_unreadCountBox.get("count") ?? 0) > 0;
// debugPrint("NOTIF_COUNT: ${_unreadCountBox.get("count")}");
return DB.instance
.values<NotificationModel>(boxName: DB.boxNameNotifications)
.where((element) => element.read == false)
.isNotEmpty;
// return count;
}
bool hasUnreadNotificationsFor(String walletId) {
return DB.instance
.values<NotificationModel>(boxName: DB.boxNameNotifications)
.where(
(element) => element.read == false && element.walletId == walletId)
.isNotEmpty;
}
List<NotificationModel> get notifications {
final list = DB.instance
.values<NotificationModel>(boxName: DB.boxNameNotifications)
.toList(growable: false)
.reversed
.toList(growable: false);
return list;
}
Future<void> add(
NotificationModel notification,
bool shouldNotifyListeners,
) async {
await DB.instance.put<NotificationModel>(
boxName: DB.boxNameNotifications,
key: notification.id,
value: notification,
);
if (notification.shouldWatchForUpdates) {
if (notification.txid != null) {
_addWatchedTxNotification(notification);
}
if (notification.changeNowId != null) {
_addWatchedTradeNotification(notification);
}
}
if (shouldNotifyListeners) {
notifyListeners();
}
}
Future<void> delete(
NotificationModel notification,
bool shouldNotifyListeners,
) async {
await DB.instance.delete<NotificationModel>(
boxName: DB.boxNameNotifications, key: notification.id);
await _deleteWatchedTradeNotification(notification);
await _deleteWatchedTxNotification(notification);
if (shouldNotifyListeners) {
notifyListeners();
}
}
Future<void> markAsRead(int id, bool shouldNotifyListeners) async {
final model = DB.instance
.get<NotificationModel>(boxName: DB.boxNameNotifications, key: id)!;
await DB.instance.put<NotificationModel>(
boxName: DB.boxNameNotifications,
key: model.id,
value: model.copyWith(read: true),
);
NotificationApi.clearNotification(id);
if (shouldNotifyListeners) {
notifyListeners();
}
}
}