public async Task <HttpResponseMessage> ReceiveMessage()
        {
            var result = new HttpResponseMessage(HttpStatusCode.Accepted);

            using (var db = new ControlCashDbContext())
            {
                var wallets = await db.WalletRepository.GetAllAsync();

                foreach (var wallet in wallets)
                {
                    var users = await db.UserRepository.FindAllAsync(a => a.WalletId == wallet.WalletId);

                    foreach (var user in users)
                    {
                        var date     = DateTime.Now.AddDays(-7);
                        var moviment = await db.MovimentHistoryRepository.FindAllAsync(a => a.Date >= date && a.UserId == user.UserId);

                        if (moviment.Count() == 0)
                        {
                            using (var client = new HttpClient())
                            {
                                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Key", "Y29udHJvbGNhc2g6Y1NlYWJQbWdKUmVOUFo4c3lPR0Q=");

                                var message = new Message()
                                {
                                    Content = "Já faz um tempo que você não cadastra nada, isto está correto?",
                                    To      = $"{user.UserIdentifier}@messenger.gw.msging.net",
                                    Id      = Guid.NewGuid().ToString(),
                                    From    = "*****@*****.**"
                                };

                                var json    = JsonConvert.SerializeObject(message.ToDocument());
                                var content = new StringContent(json, Encoding.UTF8, "application/json");

                                var response = await client.PostAsync("https://msging.net/messages", content);
                            };
                        }
                    }
                }
            }

            return(result);
        }
        public async Task <HttpResponseMessage> ReceiveMessage()
        {
            var result  = new HttpResponseMessage(HttpStatusCode.Accepted);
            var request = await Request.Content.ReadAsStringAsync();

            var requestMessage = JsonConvert.DeserializeObject <Message>(request);
            var queryRequest   = await _blipAiMessageTranslator.TranslateMessageAsync(request);

            var queryAppService = _apiAiAppServiceFactory.CreateQueryAppService(_urlApiAi,
                                                                                _apiKey);
            var queryResponse = await queryAppService.PostQueryAsync(queryRequest);

            if (queryResponse.Result.Action.Equals("savevalue"))
            {
                using (var db = new ControlCashDbContext())
                {
                    var userId = requestMessage.From.Name.Split('@')[0];

                    var user = db.UserRepository.Find(a => a.UserIdentifier.Equals(userId));

                    var value = decimal.Parse(queryResponse.Result.Parameters["number"].ToString());
                    if (user != null)
                    {
                        var wallet = db.WalletRepository.Find(a => a.WalletId == user.WalletId);
                        if (wallet != null)
                        {
                            if (queryResponse.Result.Contexts[0].Parameters["Type"].ToString().Equals("Entrada"))
                            {
                                wallet.Balance += value;
                                await db.SaveChanges();

                                db.MovimentHistoryRepository.Add(new Entities.MovimentHistory()
                                {
                                    Date        = DateTime.Now,
                                    Description = queryResponse.Result.Contexts[0].Parameters["TagEntrada.original"].ToString(),
                                    UserId      = user.UserId,
                                    Value       = value
                                });
                                await db.SaveChanges();
                            }
                            else
                            {
                                wallet.Balance -= value;
                                await db.SaveChanges();

                                var tagSaida = queryResponse.Result.Contexts[0].Parameters["TagSaida.original"].ToString();
                                if (!string.IsNullOrEmpty(tagSaida))
                                {
                                    var limit        = db.LimitRepository.Find(a => a.TagDescription.Equals(tagSaida));
                                    var limitHistory = db.LimitHistoryRepository.Find(a => a.Month == DateTime.Now.Month && a.Year == DateTime.Now.Year && a.TagDescription.Equals(tagSaida));
                                    if (limit != null)
                                    {
                                        var text = string.Empty;
                                        if (limitHistory != null)
                                        {
                                            limitHistory.Balance += value;
                                            await db.SaveChanges();

                                            var requestSendMessage = new Message()
                                            {
                                                Content = await ReturnMessage(limitHistory),
                                                From    = requestMessage.To,
                                                Id      = Guid.NewGuid().ToString(),
                                                To      = requestMessage.From
                                            };
                                            await _messageAppService.SendMessageAsync(requestSendMessage);
                                        }
                                        else
                                        {
                                            limitHistory = new LimitHistory()
                                            {
                                                Balance        = 0,
                                                LimitValue     = limit.LimitValue,
                                                Month          = (short)DateTime.Now.Month,
                                                Year           = (short)DateTime.Now.Year,
                                                TagDescription = tagSaida
                                            };

                                            limitHistory.Balance += value;
                                            await db.SaveChanges();

                                            var requestSendMessage = new Message()
                                            {
                                                Content = await ReturnMessage(limitHistory),
                                                From    = requestMessage.To,
                                                Id      = Guid.NewGuid().ToString(),
                                                To      = requestMessage.From
                                            };
                                            await _messageAppService.SendMessageAsync(requestSendMessage);

                                            db.LimitHistoryRepository.Add(limitHistory);
                                            await db.SaveChanges();
                                        }
                                    }
                                }
                                wallet.Balance -= value;
                                await db.SaveChanges();

                                db.MovimentHistoryRepository.Add(new Entities.MovimentHistory()
                                {
                                    Date        = DateTime.Now,
                                    Description = queryResponse.Result.Contexts[0].Parameters["TagSaida.original"].ToString(),
                                    UserId      = user.UserId,
                                    Value       = value
                                });
                                await db.SaveChanges();
                            }
                        }
                        else
                        {
                            var requestSendMessage = new Message()
                            {
                                Content = "Desculpa mas não existe uma conta criada para você! Alguém entrará em contato com você para verificar!",
                                From    = requestMessage.To,
                                Id      = Guid.NewGuid().ToString(),
                                To      = requestMessage.From
                            };
                            await _messageAppService.SendMessageAsync(requestSendMessage);
                        }
                    }
                    else
                    {
                        db.UserRepository.Add(new Entities.User()
                        {
                            UserIdentifier = userId,
                            Wallet         = new Wallet()
                            {
                                Balance = 0
                            }
                        });
                        await db.SaveChanges();

                        var requestSendMessage = new Message()
                        {
                            Content = "Sua conta foi criada com sucesso!",
                            From    = requestMessage.To,
                            Id      = Guid.NewGuid().ToString(),
                            To      = requestMessage.From
                        };
                        await _messageAppService.SendMessageAsync(requestSendMessage);
                    }
                }
            }

            var documents = await _blipAiMessageTranslator.TranslateAsync(queryResponse);

            foreach (var item in documents)
            {
                var requestSendMessage = new Message()
                {
                    Content = item,
                    From    = requestMessage.To,
                    Id      = Guid.NewGuid().ToString(),
                    To      = requestMessage.From
                };
                await _messageAppService.SendMessageAsync(requestSendMessage);

                Thread.Sleep(500);
            }
            return(result);
        }