private async Task <List <HandlerServiceResult> > ConfigureStatsCategory(string answer, User user)
        {
            answer = answer.Trim();

            if (string.IsNullOrEmpty(answer))
            {
                return(new List <HandlerServiceResult>
                {
                    _resultService.BuildEmptyAnswerErrorResult()
                });
            }

            var categories = await _categoryDocumentService.GetByUserIdAsync(user.Id);

            var category = categories.FirstOrDefault(c => c.Name.Equals(answer));

            if (category == null)
            {
                return(new List <HandlerServiceResult>
                {
                    _resultService.BuildCategoryNotFoundErrorResult()
                });
            }

            user.Context.CategoryId  = category.Id;
            user.Context.CurrentNode = user.Context.CurrentNode.Children.FirstOrDefault();

            await _userDocumentService.UpdateAsync(user);

            return(new List <HandlerServiceResult>
            {
                await _questionService.BuildQuestion(user)
            });
        }
        private async Task <List <HandlerServiceResult> > ConfigureCategoryEdit(string answer, User user)
        {
            answer = answer.Trim();

            List <HandlerServiceResult> result;

            var categories = await _categoryDocumentService.GetByUserIdAsync(user.Id);

            var categoryToEdit = categories.FirstOrDefault(c => c.Name.Equals(answer));

            if (categoryToEdit != null)
            {
                user.Context.CurrentNode = user.Context.CurrentNode.Children.FirstOrDefault();
                user.Context.CategoryId  = categoryToEdit.Id;

                result = new List <HandlerServiceResult>
                {
                    await _questionService.BuildQuestion(user)
                };
            }
            else
            {
                user.Context.CurrentNode.Question = QuestionsEnum.None;

                user.Context.CategoryId = null;

                result = new List <HandlerServiceResult>
                {
                    _resultService.BuildCategoryNotFoundErrorResult()
                };
            }

            await _userDocumentService.UpdateAsync(user);

            return(result);
        }
        public async Task <List <HandlerServiceResult> > BuildStatistics(User user, CategoryTypeEnum type = CategoryTypeEnum.None)
        {
            var result = new List <HandlerServiceResult>
            {
                new HandlerServiceResult
                {
                    Message    = "Here's your statistics:",
                    StatusCode = StatusCodeEnum.Ok
                }
            };

            var categories = await _categoryDocumentService.GetByUserIdAsync(user.Id);

            if (type != CategoryTypeEnum.None)
            {
                categories = categories.Where(c => c.Type == type && c.Configured).ToList();
            }

            foreach (var category in categories)
            {
                if (category.Type == CategoryTypeEnum.Income)
                {
                    result.Add(new HandlerServiceResult
                    {
                        Message = $"{category.Name}: +{BuildAmountWithCurrency((float) category.IncomeForThisMonthInCents / 100, category.Currency)} this month; " +
                                  $"+{BuildAmountWithCurrency((float) category.IncomeInCents / 100, category.Currency)} for all time.\n",
                        StatusCode = StatusCodeEnum.Ok
                    });
                }
                else
                {
                    result.Add(new HandlerServiceResult
                    {
                        Message = $"{category.Name}: -{BuildAmountWithCurrency((float)category.ExpenseForThisMonthInCents / 100, category.Currency)} this month; " +
                                  $"-{BuildAmountWithCurrency((float)category.ExpenseInCents / 100, category.Currency)} for all time.\n",
                        StatusCode = StatusCodeEnum.Ok
                    });
                }
            }

            return(result);
        }
        private async Task <List <HandlerServiceResult> > ConfigureOperationType(CategoryTypeEnum type, User user)
        {
            HandlerServiceResult nextQuestion;

            var categories = await _categoryDocumentService.GetByUserIdAsync(user.Id);

            categories = categories.Where(c => c.Configured && c.Type == type).ToList();

            if (categories.Count > 0)
            {
                var operation = new Operation
                {
                    Configured = false,
                    Id         = _operationDocumentService.GenerateNewId()
                };

                await _operationDocumentService.InsertAsync(operation);

                user.Context = new Context
                {
                    OperationId  = operation.Id,
                    CategoryType = type,
                    CurrentNode  = _tree
                };

                nextQuestion = await _questionService.BuildQuestion(user);
            }
            else
            {
                nextQuestion = _resultService.BuildOperationTypeCleanCategoryList();
            }

            await _userDocumentService.UpdateAsync(user);

            return(new List <HandlerServiceResult> {
                nextQuestion
            });
        }
 public async Task <List <Category> > GetUserCategories(string userId)
 {
     return(await _categoryDocumentService.GetByUserIdAsync(userId));
 }