stack_wallet/lib/services/notifications_service.dart

327 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/response_objects/trade.dart';
import 'package:stackwallet/models/notification_model.dart';
import 'package:stackwallet/services/exchange/change_now/change_now_exchange.dart';
import 'package:stackwallet/services/exchange/exchange_response.dart';
import 'package:stackwallet/services/exchange/simpleswap/simpleswap_exchange.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;
NotificationsService._();
static final NotificationsService _instance = NotificationsService._();
static NotificationsService get instance => _instance;
Future<void> init({
required NodeService nodeService,
required TradesService tradesService,
required Prefs prefs,
}) async {
this.nodeService = nodeService;
this.tradesService = tradesService;
this.prefs = prefs;
}
// 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) {
try {
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
}
}
} catch (e, s) {
Logging.instance.log("$e $s", level: LogLevel.Error);
}
}
}
void _checkTrades() async {
for (final notification in _watchedChangeNowTradeNotifications) {
final id = notification.changeNowId!;
final trades =
tradesService.trades.where((element) => element.tradeId == id);
if (trades.isEmpty) {
return;
}
final oldTrade = trades.first;
late final ExchangeResponse<Trade> response;
switch (oldTrade.exchangeName) {
case SimpleSwapExchange.exchangeName:
response = await SimpleSwapExchange().updateTrade(oldTrade);
break;
case ChangeNowExchange.exchangeName:
response = await ChangeNowExchange().updateTrade(oldTrade);
break;
default:
return;
}
if (response.value == null) {
return;
}
final trade = response.value!;
// only update if status has changed
if (trade.status != notification.title) {
bool shouldWatchForUpdates = true;
// TODO: make sure we set shouldWatchForUpdates to correct value here
switch (trade.status) {
case "Refunded":
case "refunded":
case "Failed":
case "failed":
case "closed":
case "expired":
case "Finished":
case "finished":
shouldWatchForUpdates = false;
break;
default:
shouldWatchForUpdates = true;
}
final updatedNotification = notification.copyWith(
title: trade.status,
shouldWatchForUpdates: shouldWatchForUpdates,
);
// remove from watch list if shouldWatchForUpdates was changed
if (!shouldWatchForUpdates) {
await _deleteWatchedTradeNotification(notification);
}
// replaces the current notification with the updated one
unawaited(add(updatedNotification, true));
// update the trade in db
// over write trade stored in db with updated version
await tradesService.edit(trade: trade, 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();
}
}
}