Ejemplo n.º 1
0
        public async Task <IStepResult> ResultAsync(Gem gem)
        {
            try
            {
                var tokenData = await _uniswapService.FetchTokenAsync(gem.Id);

                var tokenInfo = SharedMessageContent.TokenAndLiquidityDataContent(gem.Recently, gem.Symbol, tokenData);

                return(new StepResult(StepResultType.Success, tokenInfo, AudienceType.PREMIUM));
            }
            catch (Exception ex)
            {
                return(await Task.FromResult(new StepResult(StepResultType.Error, ex.GetFullMessage(), AudienceType.PREMIUM)));
            }
        }
Ejemplo n.º 2
0
        public async Task <Notified> SendAsync(IEnumerable <Gem> gems)
        {
            var result = new Notified();

            try
            {
                if (gems.AnyAndNotNull())
                {
                    foreach (var gem in gems)
                    {
                        Task <SingleServiceResponse <TokenData> >     uniTokenTask  = null;
                        Task <SingleServiceResponse <TokenInfo> >     tokenInfoTask = null;
                        Task <SingleServiceResponse <SmartContract> > contractTask  = null;
                        Task <ListServiceResponse <PairData> >        pairTask      = null;
                        Task <SingleServiceResponse <TopHolderList> > holdersTask   = null;

                        await TaskExt.Sequence(
                            () => { return(uniTokenTask = _uniswapService.FetchTokenAsync(gem.Id)); },
                            () => { return(tokenInfoTask = _ethPlorerService.FetchTokenInfoAsync(gem.Id)); },
                            () => { return(contractTask = _etherScanService.IsSmartContractVerifiedAsync(gem.Id)); },
                            () => { return(Task.Delay(1000)); },
                            () => { return(pairTask = _uniswapService.FetchPairsAsync(gem.Id)); },
                            () => { return(holdersTask = _ethPlorerService.FetchTopHoldersAsync(gem.Id, 5)); }
                            );

                        var msgPr = UniMsg.ForPremiumTelegram(
                            gem,
                            uniTokenTask.Result,
                            tokenInfoTask.Result,
                            contractTask.Result,
                            pairTask.Result,
                            holdersTask.Result);

                        var sentPr = await _telegramService.SendPremiumMessageAsync(msgPr.Item2, msgPr.Item1);

                        if (!sentPr.Success)
                        {
                            result.Message += $"Telegram Premium Error: {sentPr.Message}";
                        }

                        var msgTg = UniMsg.ForFreeTelegram(gem);

                        var sentTg = await _telegramService.SendFreeMessageAsync(msgTg.Item2, msgTg.Item1);

                        if (!sentTg.Success)
                        {
                            result.Message += $"Telegram Free Error: {sentTg.Message}";
                        }
                    }
                }
                else
                {
                    result.Message = "Nothing to send";
                }
            }
            catch (Exception ex)
            {
                result.Message = ex.GetFullMessage();
            }
            return(result);
        }