public Task EnqueueAsync( T task) { return(_queue.PutRawMessageAsync ( JsonConvert.SerializeObject(task) )); }
public async Task WarningAsync(string message) { var obj = new { Type = "Warnings", Sender = _sender, Message = message }; await _queue.PutRawMessageAsync(JsonConvert.SerializeObject(obj)); }
public Task AddCashinToMonitoring(string txHash, string userContract, BigInteger amount) { return(_queue.PutRawMessageAsync(new TransactionMonitoringMessage { UserContract = userContract, Amount = amount.ToString(), TxHash = txHash, Type = TransactionType.Cashin, PutDateTime = DateTime.UtcNow }.ToJson())); }
private async Task RepeatOperationTillWin(CoinTransactionMessage message) { var operation = await GetOperationAsync(message?.TransactionHash, message?.OperationId); if (operation == null) { return; } switch (operation.OperationType) { case HotWalletOperationType.Cashout: break; case HotWalletOperationType.Cashin: var retryMessage = new LykkePayErc20TransferMessage() { OperationId = operation.OperationId }; await _transferStartQueue.PutRawMessageAsync(retryMessage.ToJson()); break; default: return; } }
public Task Add(Guid channelId) { return(_queue.PutRawMessageAsync(new CommitmentClosingTask { ChannelId = channelId }.ToJson())); }
private async Task IndexEventsInRange(string coinAdapterAddress, Nethereum.Contracts.Event coinCashInEvent, BigInteger from, BigInteger to) { var fromBlock = new Nethereum.RPC.Eth.DTOs.BlockParameter(new Nethereum.Hex.HexTypes.HexBigInteger(from)); var toBlock = new Nethereum.RPC.Eth.DTOs.BlockParameter(new Nethereum.Hex.HexTypes.HexBigInteger(to)); var filter = await coinCashInEvent.CreateFilterBlockRangeAsync(fromBlock, toBlock); var filterByCaller = await coinCashInEvent.GetAllChanges <CoinCashinEvent>(filter); filterByCaller.ForEach(async @event => { string transactionHash = @event.Log.TransactionHash; CoinEventCashinCompletedMessage cashinTransactionMessage = new CoinEventCashinCompletedMessage() { TransactionHash = transactionHash }; await _cashinEventRepository.InsertAsync(new CashinEvent() { CoinAdapterAddress = coinAdapterAddress, Amount = @event.Event.Amount.ToString(), TransactionHash = transactionHash, UserAddress = @event.Event.Caller }); await _cashinQueue.PutRawMessageAsync(Newtonsoft.Json.JsonConvert.SerializeObject(cashinTransactionMessage)); }); await _blockSyncedRepository.InsertAsync(new BlockSynced() { BlockNumber = to.ToString(), CoinAdapterAddress = coinAdapterAddress }); }
public Task AddToReturn(string transactionHex, List <string> address) { return(_queue.PutRawMessageAsync(new ReturnOutputMessage { TransactionHex = transactionHex, Addresses = address }.ToJson())); }
public async Task CreateUpsertAssetImageCommand(IEnumerable <string> assetIds, string iconUrl, string imageUrl) { await _queue.PutRawMessageAsync(new AssetImageContext { AssetIds = assetIds, IconUrl = iconUrl, ImageUrl = imageUrl }.ToJson()); }
public Task AddToMonitoring(Guid transactionId, string transactionHash) { return(_queue.PutRawMessageAsync(new TransactionMonitoringMessage { TransactionId = transactionId, TransactionHash = transactionHash, PutDateTime = DateTime.UtcNow }.ToJson())); }
public Task AddToMonitoring(Guid commitmentId, string transactionHash) { return(_queue.PutRawMessageAsync(new SpendCommitmentMonitorindMessage() { PutDateTime = DateTime.UtcNow, TransactionHash = transactionHash, CommitmentId = commitmentId }.ToJson())); }
public Task CreateParseBlockCommand(string blockHash) { var context = new AssetDefinitionParseBlockContext { BlockHash = blockHash }; return(_queue.PutRawMessageAsync(context.ToJson())); }
public Task AddNotify(string txHash, string contract, decimal amount) { return(_queue.PutRawMessageAsync(new IssueNotifyMessage { TransactionHash = txHash, Contract = contract, Amount = amount }.ToJson())); }
public async Task RefreshOperationByIdAsync(string operationId) { IOperationToHashMatch match = await _operationToHashMatchRepository.GetAsync(operationId); if (match == null) { return; } match.TransactionHash = ""; await _operationToHashMatchRepository.InsertOrReplaceAsync(match); await _queue.PutRawMessageAsync(JsonConvert.SerializeObject(new OperationHashMatchMessage() { OperationId = match.OperationId })); }
public async Task CreateAssetCoinholdersUpdateIndexCommand(params string[] assetIds) { foreach (var assetID in assetIds) { await _queue.PutRawMessageAsync(new AssetCoinholdersUpdateIndexCommand { AssetId = assetID }.ToJson()); } }
public Task AddTask(string hash, DateTime date, string asset, string multisig) { return(_queue.PutRawMessageAsync(new PaidFeesTask { TransactionHash = hash, Date = date, Multisig = multisig, Asset = asset }.ToJson())); }
public async Task CreateCommand(string address, string email) { var msg = new AddressTransactionReportQueueCommand { Address = address, Email = email }; await _queue.PutRawMessageAsync(msg.ToJson()); }
public async Task AddCommand(Guid transactionId, TransactionCommandType type, string command) { var msg = new TransactionQueueMessage { TransactionId = transactionId, Type = type, Command = command }; await _queue.PutRawMessageAsync(msg.ToJson()); }
public async Task CreateCommand(string assetId, string email) { var msg = new AssetTransactionReportQueueCommand { AssetId = assetId, Email = email }; await _queue.PutRawMessageAsync(msg.ToJson()); }
public async Task CreateCommand(IEnumerable <string> blocks, string email) { var msg = new BlockTransactionReportQueueCommand { Blocks = blocks.ToArray(), Email = email }; await _queue.PutRawMessageAsync(msg.ToJson()); }
public Task AddTransactionFeeReserve(Guid transactionId, List <ICoin> feeCoins) { var message = new FeeReserveMonitoringMessage { PutDateTime = DateTime.UtcNow, TransactionId = transactionId, FeeCoins = feeCoins.OfType <Coin>().Select(x => new SerializableCoin(x)).ToList() }; return(_queue.PutRawMessageAsync(message.ToJson())); }
public async Task EnqueueOutputs(params Coin[] coins) { if (coins == null) { return; } foreach (var item in coins) { await _queue.PutRawMessageAsync(new SerializableCoin(item).ToJson()); } }
public async Task RetryCashoutAsync(IHotWalletOperation hotWalletCashout) { HotWalletCashoutMessage message = new HotWalletCashoutMessage() { OperationId = hotWalletCashout.OperationId }; await _hotWalletCashoutRepository.SaveAsync(hotWalletCashout); await _hotWalletCashoutQueue.PutRawMessageAsync(Newtonsoft.Json.JsonConvert.SerializeObject(message)); }
public async Task Notify(SlackMessage message) { try { await _slackQueue.PutRawMessageAsync(JsonConvert.SerializeObject(message)); } catch (Exception e) { var a = 234; } }
public async Task CreateRetrieveAssetDefinitionCommand(params string[] urls) { foreach (var url in urls) { var context = new UpdateAssetDataContext { AssetDefinitionUrl = url }; await _queue.PutRawMessageAsync(context.ToJson()); } }
public async Task UpdateUserAssignmentFail(string contractAddress, string userAddress, string coinAdapter) { var canBeRestoredInternally = !string.IsNullOrEmpty(userAddress) && userAddress != Constants.EmptyEthereumAddress; var userAssignmentFail = await _userAssignmentFailRepository.GetAsync(contractAddress); if (userAssignmentFail == null) { userAssignmentFail = new UserAssignmentFail() { CanBeRestoredInternally = canBeRestoredInternally, ContractAddress = contractAddress, NotifiedInSlack = false, FailCount = 0 }; } if (userAssignmentFail.FailCount == _attempsBeforeReassign) { if (canBeRestoredInternally) { var message = new TransferContractUserAssignment() { CoinAdapterAddress = coinAdapter, TransferContractAddress = contractAddress, UserAddress = userAddress }; await _queueUserAssignment.PutRawMessageAsync(JsonConvert.SerializeObject(message)); userAssignmentFail.FailCount = 0; } else { if (userAssignmentFail.NotifiedInSlack.HasValue && !userAssignmentFail.NotifiedInSlack.Value) { await _slackNotifier.ErrorAsync($"TransferAddress - {contractAddress}, UserAddress - {userAddress}, " + $"CoinAdapter Address - {coinAdapter} can't be restored internally"); await _userAssignmentFailRepository.SaveAsync(userAssignmentFail); } return; } } else { userAssignmentFail.FailCount++; } await _userAssignmentFailRepository.SaveAsync(userAssignmentFail); }
private async Task ResubmittTransactionAsync(string transactionHash, string operationId, IOperationResubmitt counter) { await _transactionMonitoringQueue.PutRawMessageAsync( Newtonsoft.Json.JsonConvert.SerializeObject( new CoinTransactionMessage() { TransactionHash = transactionHash, OperationId = operationId, LastError = "FROM_JOB", PutDateTime = DateTime.UtcNow } )); counter.ResubmittCount++; await _operationResubmittRepository.InsertOrReplaceAsync(counter); }
public async Task Start() { int?cnt = 0; int i = 0; while ((cnt = await _fromQueue.Count()) > 0) { var msg = await _fromQueue.GetRawMessageAsync(); await _toQueue.PutRawMessageAsync(msg.AsString); await _fromQueue.FinishRawMessageAsync(msg); Console.WriteLine($"Processed {++i} from {cnt}"); } }
public async Task AddPaidFee(Guid id, string asset, string fromClient, string toClient, decimal volume, DateTime date, string order, string tradeClient, string tradeOppositeClient, decimal tradeVolume) { var msg = new PaidFeeQueueItem { AssetId = asset, Date = date, FromClient = fromClient, Id = id, Order = order, ToClient = toClient, Volume = volume, TradeClient = tradeClient, TradeOppositeClient = tradeOppositeClient, TradeVolume = tradeVolume }; await _queue.PutRawMessageAsync(msg.ToJson()); }
public void Warning(string title, string message) { var obj = new { Data = new { BroadcastGroup = 100, MessageData = new { Subject = title, Text = message } } }; var str = "PlainTextBroadcast:" + JsonConvert.SerializeObject(obj); _queue.PutRawMessageAsync(str); }
/// <summary> /// Sends event for ethereum payment to azure queue /// </summary> /// <param name="userContract"></param> /// <param name="amount"></param> /// <returns></returns> public async Task FirePaymentEvent(string userContract, decimal amount, string trHash) { try { var model = new EthereumCashInModel { Amount = amount, Contract = userContract, TransactionHash = trHash }; var json = JsonConvert.SerializeObject(model); await _queue.PutRawMessageAsync(json); } catch (Exception e) { await _logger.WriteErrorAsync("ApiCallService", "FirePaymentEvent", $"Contract : {userContract}, amount: {amount}", e); } }